From ce3eb55ada3d106332459a9151898a2828610d44 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Thu, 16 Dec 2021 12:25:02 +0100 Subject: [PATCH] Introduce simple reflection function on vk-structs Used that to simplify comparison operators. --- VulkanHppGenerator.cpp | 147 +- VulkanHppGenerator.hpp | 13 +- vulkan/vulkan_structs.hpp | 15957 +++++++++++++++++++++++++++++------- 3 files changed, 13087 insertions(+), 3030 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index d0697b9..b433418 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -11693,56 +11693,6 @@ std::string VulkanHppGenerator::generateStructAssignmentOperators( return replaceWithMap( assignmentFromVulkanType, { { "structName", stripPrefix( structData.first, "Vk" ) } } ); } -std::string - VulkanHppGenerator::generateStructCompareOperators( std::pair const & structData ) const -{ - static const std::set simpleTypes = { "char", "double", "DWORD", "float", "HANDLE", - "HINSTANCE", "HMONITOR", "HWND", "int", "int8_t", - "int16_t", "int32_t", "int64_t", "LPCWSTR", "size_t", - "uint8_t", "uint16_t", "uint32_t", "uint64_t" }; - // two structs are compared by comparing each of the elements - std::string compareMembers; - std::string intro = ""; - for ( size_t i = 0; i < structData.second.members.size(); i++ ) - { - MemberData const & member = structData.second.members[i]; - auto typeIt = m_types.find( member.type.type ); - assert( typeIt != m_types.end() ); - if ( ( typeIt->second.category == TypeCategory::Requires ) && member.type.postfix.empty() && - ( simpleTypes.find( member.type.type ) == simpleTypes.end() ) ) - { - // this type might support operator==()... that is, use memcmp - compareMembers += - intro + "( memcmp( &" + member.name + ", &rhs." + member.name + ", sizeof( " + member.type.type + " ) ) == 0 )"; - } - else - { - // for all others, we use the operator== of that type - compareMembers += intro + "( " + member.name + " == rhs." + member.name + " )"; - } - intro = "\n && "; - } - - static const std::string compareTemplate = R"( -#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) - auto operator<=>( ${name} const & ) const = default; -#else - bool operator==( ${name} const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ${compareMembers}; - } - - bool operator!=( ${name} const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif -)"; - - return replaceWithMap( compareTemplate, - { { "name", stripPrefix( structData.first, "Vk" ) }, { "compareMembers", compareMembers } } ); -} - std::string VulkanHppGenerator::generateStructConstructors( std::pair const & structData ) const { @@ -11993,15 +11943,13 @@ std::string VulkanHppGenerator::generateStructHashSum( std::string const & hashSum += " {\n"; if ( member.arraySizes.size() == 1 ) { - hashSum += - " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i] );\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i] );\n"; } else { hashSum += " for ( size_t j=0; j < " + member.arraySizes[1] + "; ++j )\n"; hashSum += " {\n"; - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + - "[i][j] );\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i][j] );\n"; hashSum += " }\n"; } hashSum += " }\n"; @@ -12040,17 +11988,52 @@ std::string VulkanHppGenerator::generateStructure( std::pair +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( ${memberNames} ); + } +)"; + + reflect = replaceWithMap( reflectTemplate, { { "memberNames", memberNames }, { "memberTypes", memberTypes } } ); + } + // operator==() and operator!=() // only structs without a union as a member can have a meaningfull == and != operation; we filter them out std::string compareOperators; if ( !containsUnion( structure.first ) ) { - compareOperators += generateStructCompareOperators( structure ); - } + static const std::string compareOperatorsTemplate = R"( +#if defined(VULKAN_HPP_HAS_SPACESHIP_OPERATOR) + auto operator<=>( ${structureType} const & ) const = default; +#else + bool operator==( ${structureType} const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() == rhs.reflect(); + } - // the member variables - std::string members, sTypeValue; - std::tie( members, sTypeValue ) = generateStructMembers( structure, " " ); + bool operator!=( ${structureType} const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return this->reflect() != rhs.reflect(); + } +#endif +)"; + compareOperators = replaceWithMap( compareOperatorsTemplate, { { "structureType", structureType } } ); + } static const std::string structureTemplate = R"( struct ${structureType} { @@ -12069,9 +12052,8 @@ ${constructorAndSetters} { return *reinterpret_cast( this ); } - +${reflect} ${compareOperators} - public: ${members} }; @@ -12080,7 +12062,6 @@ ${members} VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "${structureType} is not nothrow_move_constructible!" ); )"; - std::string structureType = stripPrefix( structure.first, "Vk" ); std::string allowDuplicate, typeValue; if ( !sTypeValue.empty() ) { @@ -12094,6 +12075,7 @@ ${members} { "constructorAndSetters", constructorAndSetters }, { "compareOperators", compareOperators }, { "members", members }, + { "reflect", reflect }, { "structureType", structureType }, { "typeValue", typeValue } } ); @@ -12203,36 +12185,36 @@ std::string VulkanHppGenerator::generateStructForwardDeclarations( std::vector - VulkanHppGenerator::generateStructMembers( std::pair const & structData, - std::string const & prefix ) const +std::tuple + VulkanHppGenerator::generateStructMembers( std::pair const & structData ) const { - std::string str, sTypeValue; + std::string members, memberNames, memberTypes, sTypeValue; for ( auto const & member : structData.second.members ) { - str += prefix; + members += " "; + std::string type; if ( !member.bitCount.empty() && beginsWith( member.type.type, "Vk" ) ) { assert( member.type.prefix.empty() && member.type.postfix.empty() ); // never encounterd a different case - str += member.type.type; + type = member.type.type; } else if ( member.arraySizes.empty() ) { - str += member.type.compose( "VULKAN_HPP_NAMESPACE" ); + type = member.type.compose( "VULKAN_HPP_NAMESPACE" ); } else { assert( member.type.prefix.empty() && member.type.postfix.empty() ); - str += generateStandardArrayWrapper( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ); + type = generateStandardArrayWrapper( member.type.compose( "VULKAN_HPP_NAMESPACE" ), member.arraySizes ); } - str += " " + member.name; + members += type + " " + member.name; if ( !member.value.empty() ) { // special handling for members with legal value: use it as the default - str += " = "; + members += " = "; if ( member.type.type == "uint32_t" ) { - str += member.value; + members += member.value; } else { @@ -12244,7 +12226,7 @@ std::pair [&enumValue]( EnumValueData const & evd ) { return enumValue == evd.name; } ); assert( valueIt != enumIt->second.values.end() ); std::string valueName = generateEnumValueName( enumIt->first, valueIt->name, enumIt->second.isBitmask, m_tags ); - str += stripPrefix( member.type.type, "Vk" ) + "::" + valueName; + members += stripPrefix( member.type.type, "Vk" ) + "::" + valueName; if ( member.name == "sType" ) { sTypeValue = valueName; @@ -12257,27 +12239,30 @@ std::pair assert( member.arraySizes.empty() || member.bitCount.empty() ); if ( !member.bitCount.empty() ) { - str += " : " + member.bitCount; // except for bitfield members, where no default member initializatin is - // supported (up to C++20) + members += " : " + member.bitCount; // except for bitfield members, where no default member initializatin is + // supported (up to C++20) } else { - str += " = "; + members += " = "; auto enumIt = m_enums.find( member.type.type ); if ( member.arraySizes.empty() && ( enumIt != m_enums.end() ) && member.type.postfix.empty() ) { - str += + members += generateEnumInitializer( member.type, member.arraySizes, enumIt->second.values, enumIt->second.isBitmask ); } else { - str += "{}"; + members += "{}"; } } } - str += ";\n"; + members += ";\n"; + + memberNames += member.name + ", "; + memberTypes += type + " const &, "; } - return std::make_pair( str, sTypeValue ); + return std::make_tuple( members, stripPostfix( memberNames, ", " ), stripPostfix( memberTypes, ", " ), sTypeValue ); } std::string VulkanHppGenerator::generateStructSetter( std::string const & structureName, diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index c7bcaa5..20bc762 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -1214,13 +1214,12 @@ private: std::string generateStruct( std::pair const & structure, std::set & listedStructs ) const; std::string generateStructAssignmentOperators( std::pair const & structure ) const; - std::string generateStructCompareOperators( std::pair const & structure ) const; std::string generateStructConstructors( std::pair const & structData ) const; std::string generateStructConstructorsEnhanced( std::pair const & structData ) const; std::string generateStructConstructorArgument( bool listedArgument, MemberData const & memberData, bool withDefault ) const; std::string generateStructHashStructure( std::pair const & structure, - std::set & listedStructs ) const; + std::set & listedStructs ) const; std::string generateStructHashSum( std::string const & structName, std::vector const & members ) const; std::string generateStructure( std::pair const & structure ) const; std::string generateStructExtendsStructs( std::vector const & requireData, @@ -1228,11 +1227,11 @@ private: std::string const & title ) const; std::string generateStructForwardDeclarations( std::vector const & requireData, std::string const & title ) const; - std::pair generateStructMembers( std::pair const & structData, - std::string const & prefix ) const; - std::string generateStructSetter( std::string const & structureName, - std::vector const & memberData, - size_t index ) const; + std::tuple + generateStructMembers( std::pair const & structData ) const; + std::string generateStructSetter( std::string const & structureName, + std::vector const & memberData, + size_t index ) const; std::string generateStructSubConstructor( std::pair const & structData ) const; std::string generateSuccessCheck( std::vector const & successCodes ) const; std::string generateSuccessCodeList( std::vector const & successCodes ) const; diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index 59dd83a..f08cf97 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -96,18 +96,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minX, minY, minZ, maxX, maxY, maxZ ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AabbPositionsKHR const & ) const = default; #else bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && - ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ ); + return this->reflect() == rhs.reflect(); } bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -169,8 +178,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*/ }; @@ -288,6 +297,25 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; const void * pNext = {}; @@ -384,6 +412,19 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, data, stride ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; const void * pNext = {}; @@ -475,6 +516,19 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, arrayOfPointers, data ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; const void * pNext = {}; @@ -635,6 +689,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryKHR; const void * pNext = {}; @@ -698,8 +766,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*/ }; @@ -894,6 +962,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + type, + flags, + mode, + srcAccelerationStructure, + dstAccelerationStructure, + geometryCount, + pGeometries, + ppGeometries, + scratchData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; const void * pNext = {}; @@ -999,18 +1097,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && - ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1106,19 +1213,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureSize == rhs.accelerationStructureSize ) && - ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1248,19 +1367,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1431,22 +1565,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + vertexData, + vertexOffset, + vertexCount, + vertexStride, + vertexFormat, + indexData, + indexOffset, + indexCount, + indexType, + transformData, + transformOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryTrianglesNV const & ) const = default; #else bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1553,18 +1716,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aabbData, numAABBs, stride, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryAABBNV const & ) const = default; #else bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && - ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1641,17 +1818,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( triangles, aabbs ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryDataNV const & ) const = default; #else bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1736,18 +1923,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeometryNV const & ) const = default; #else bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && - ( geometry == rhs.geometry ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1886,19 +2086,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInfoNV const & ) const = default; #else bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && - ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) && - ( pGeometries == rhs.pGeometries ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -1991,18 +2205,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compactedSize, info ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default; #else bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && - ( info == rhs.info ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2087,17 +2313,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2183,6 +2421,18 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexData ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; const void * pNext = {}; @@ -2248,17 +2498,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( matrix ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TransformMatrixKHR const & ) const = default; #else bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( matrix == rhs.matrix ); + return this->reflect() == rhs.reflect(); } bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2363,20 +2623,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transform, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default; #else bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && - ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2500,20 +2777,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, + transformT1, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && - ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2606,18 +2902,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, accelerationStructure ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && - ( accelerationStructure == rhs.accelerationStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2709,18 +3017,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInstances, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default; #else bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && - ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -2906,20 +3226,42 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#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 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SRTDataNV const & ) const = default; #else bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3050,20 +3392,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, + transformT1, + instanceCustomIndex, + mask, + instanceShaderBindingTableRecordOffset, + flags, + accelerationStructureReference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default; #else bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && - ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && - ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3219,6 +3580,18 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, flags, data ); + } + public: VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type = VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV::eStatic; @@ -3290,17 +3663,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVersionData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default; #else bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); + return this->reflect() == rhs.reflect(); } bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3409,19 +3792,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireNextImageInfoKHR const & ) const = default; #else bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && - ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3509,17 +3906,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, timeout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default; #else bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3630,19 +4040,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AllocationCallbacks const & ) const = default; #else bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && - ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) && - ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree ); + return this->reflect() == rhs.reflect(); } bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3729,17 +4152,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( r, g, b, a ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComponentMapping const & ) const = default; #else bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a ); + return this->reflect() == rhs.reflect(); } bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -3817,22 +4253,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -3927,22 +4386,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4021,18 +4503,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && - ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4101,18 +4595,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, androidHardwareBufferUsage ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default; # else bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4200,17 +4703,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -4319,19 +4835,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ApplicationInfo const & ) const = default; #else bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) && - ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) && - ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4474,20 +5004,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription const & ) const = default; #else bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4635,20 +5181,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + format, + samples, + loadOp, + storeOp, + stencilLoadOp, + stencilStoreOp, + initialLayout, + finalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescription2 const & ) const = default; #else bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4747,18 +5320,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default; #else bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) && - ( stencilFinalLayout == rhs.stencilFinalLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4836,17 +5421,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachment, layout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference const & ) const = default; #else bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( attachment == rhs.attachment ) && ( layout == rhs.layout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -4931,18 +5526,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachment, layout, aspectMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReference2 const & ) const = default; #else bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && - ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5023,17 +5631,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default; #else bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5153,19 +5771,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default; #else bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && - ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5240,17 +5870,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent2D const & ) const = default; #else bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ); + return this->reflect() == rhs.reflect(); } bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5314,17 +5954,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationEXT const & ) const = default; #else bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5444,20 +6094,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SampleLocationsInfoEXT const & ) const = default; #else bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) && - ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && - ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5537,17 +6200,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachmentIndex, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default; #else bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5607,17 +6280,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseInStructure const & ) const = default; #else bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5675,17 +6359,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BaseOutStructure const & ) const = default; #else bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5818,20 +6512,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default; #else bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -5939,18 +6646,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6045,18 +6764,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, memory, memoryOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindBufferMemoryInfo const & ) const = default; #else bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6128,17 +6860,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset2D const & ) const = default; #else bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6201,17 +6943,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Rect2D const & ) const = default; #else bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6341,20 +7093,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default; #else bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && - ( pDeviceIndices == rhs.pDeviceIndices ) && - ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && - ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6451,18 +7216,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, memory, memoryOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemoryInfo const & ) const = default; #else bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6549,18 +7327,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, imageIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default; #else bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && - ( imageIndex == rhs.imageIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6639,17 +7429,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default; #else bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6736,17 +7538,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, indexType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6808,17 +7620,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( groupIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default; #else bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( groupIndex == rhs.groupIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -6912,18 +7734,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( resourceOffset, size, memory, memoryOffset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseMemoryBind const & ) const = default; #else bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7022,17 +7857,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default; #else bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7131,17 +7978,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7218,17 +8077,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, arrayLayer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresource const & ) const = default; #else bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7300,17 +8169,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Offset3D const & ) const = default; #else bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); + return this->reflect() == rhs.reflect(); } bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7385,17 +8264,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Extent3D const & ) const = default; #else bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); + return this->reflect() == rhs.reflect(); } bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7500,18 +8389,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subresource, offset, extent, memory, memoryOffset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBind const & ) const = default; #else bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && - ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7611,17 +8514,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryBindInfo const & ) const = default; #else bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7848,22 +8763,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphores, + bufferBindCount, + pBufferBinds, + imageOpaqueBindCount, + pImageOpaqueBinds, + imageBindCount, + pImageBinds, + signalSemaphoreCount, + pSignalSemaphores ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindSparseInfo const & ) const = default; #else bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -7955,17 +8897,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, stride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default; #else bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); + return this->reflect() == rhs.reflect(); } bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8050,18 +9002,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceLayers const & ) const = default; #else bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && - ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8159,19 +9120,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit2KHR const & ) const = default; #else bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffsets == rhs.dstOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8328,20 +9302,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BlitImageInfo2KHR const & ) const = default; #else bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -8437,18 +9427,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -8570,20 +9572,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minBufferCount, + maxBufferCount, + minBufferCountForCamping, + minBufferCountForDedicatedSlack, + minBufferCountForSharedSlack ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && - ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && - ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) && - ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -8669,18 +9690,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collectionToken ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -8772,18 +9802,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -8862,17 +9904,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorSpace ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default; # else bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace ); + return this->reflect() == rhs.reflect(); } bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -9045,24 +10097,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + memoryTypeBits, + bufferCount, + createInfoIndex, + sysmemPixelFormat, + formatFeatures, + sysmemColorSpaceIndex, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default; # else bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -9220,20 +10299,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCreateInfo const & ) const = default; #else bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9335,19 +10428,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && - ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && - ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -9432,17 +10537,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcOffset, dstOffset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy const & ) const = default; #else bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9527,18 +10644,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcOffset, dstOffset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferCopy2KHR const & ) const = default; #else bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && - ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9617,17 +10747,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default; #else bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9703,17 +10845,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferDeviceAddressInfo const & ) const = default; #else bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9824,19 +10976,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy const & ) const = default; #else bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && - ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && - ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -9951,20 +11116,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferImageCopy2KHR const & ) const = default; #else bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10095,20 +11275,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier const & ) const = default; #else bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10260,21 +11456,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcStageMask, + srcAccessMask, + dstStageMask, + dstAccessMask, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + buffer, + offset, + size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default; #else bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10359,17 +11581,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10450,17 +11682,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default; #else bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10572,18 +11814,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, buffer, format, offset, range ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( BufferViewCreateInfo const & ) const = default; #else bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && - ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range ); + return this->reflect() == rhs.reflect(); } bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10664,17 +11921,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timeDomain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default; #else bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain ); + return this->reflect() == rhs.reflect(); } bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10736,18 +12005,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointData2NV const & ) const = default; #else bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && - ( pCheckpointMarker == rhs.pCheckpointMarker ); + return this->reflect() == rhs.reflect(); } bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10810,18 +12091,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CheckpointDataNV const & ) const = default; #else bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && - ( pCheckpointMarker == rhs.pCheckpointMarker ); + return this->reflect() == rhs.reflect(); } bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -10940,17 +12233,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( depth, stencil ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ClearDepthStencilValue const & ) const = default; #else bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( depth == rhs.depth ) && ( stencil == rhs.stencil ); + return this->reflect() == rhs.reflect(); } bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11073,6 +12376,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, colorAttachment, clearValue ); + } + public: VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask = {}; uint32_t colorAttachment = {}; @@ -11142,17 +12456,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rect, baseArrayLayer, layerCount ); + } + #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 { - return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11225,17 +12549,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pixelX, pixelY, sample ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleLocationNV const & ) const = default; #else bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample ); + return this->reflect() == rhs.reflect(); } bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11348,18 +12682,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default; #else bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && - ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11450,18 +12796,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandPool, level, commandBufferCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferAllocateInfo const & ) const = default; #else bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && - ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11584,20 +12943,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceInfo const & ) const = default; #else bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11688,18 +13062,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pInheritanceInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferBeginInfo const & ) const = default; #else bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pInheritanceInfo == rhs.pInheritanceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11784,18 +13170,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRenderingEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default; #else bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -11891,18 +13286,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform, renderArea ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && - ( renderArea == rhs.renderArea ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12073,22 +13480,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + viewMask, + colorAttachmentCount, + pColorAttachmentFormats, + depthAttachmentFormat, + stencilAttachmentFormat, + rasterizationSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default; #else bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12199,18 +13627,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, width, height, minDepth, maxDepth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Viewport const & ) const = default; #else bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && - ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth ); + return this->reflect() == rhs.reflect(); } bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12307,18 +13744,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default; #else bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) && - ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12406,18 +13856,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandBuffer, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default; #else bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12502,18 +13964,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CommandPoolCreateInfo const & ) const = default; #else bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12593,17 +14067,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( constantID, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationMapEntry const & ) const = default; #else bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12721,18 +14205,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( mapEntryCount, pMapEntries, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SpecializationInfo const & ) const = default; #else bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && - ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12839,18 +14335,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default; #else bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && - ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -12967,19 +14478,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ComputePipelineCreateInfo const & ) const = default; #else bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && - ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && - ( basePipelineIndex == rhs.basePipelineIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13079,18 +14604,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, offset, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default; #else bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && - ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13182,17 +14720,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( major, minor, subminor, patch ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ConformanceVersion const & ) const = default; #else bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch ); + return this->reflect() == rhs.reflect(); } bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13325,19 +14873,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13442,18 +15007,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default; #else bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && - ( mode == rhs.mode ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13559,6 +15137,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; const void * pNext = {}; @@ -13685,18 +15277,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferInfo2KHR const & ) const = default; #else bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && - ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13835,19 +15441,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default; #else bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && - ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -13929,17 +15549,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default; #else bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14065,20 +15697,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyDescriptorSet const & ) const = default; #else bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14194,19 +15842,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy2KHR const & ) const = default; #else bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14354,20 +16016,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageInfo2KHR const & ) const = default; #else bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14508,19 +16184,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default; #else bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14626,6 +16316,20 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; const void * pNext = {}; @@ -14710,17 +16414,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, module, pName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default; #else bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -14930,21 +16647,53 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + function, + gridDimX, + gridDimY, + gridDimZ, + blockDimX, + blockDimY, + blockDimZ, + sharedMemBytes, + paramCount, + pParams, + extraCount, + pExtras ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuLaunchInfoNVX const & ) const = default; #else bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15053,17 +16802,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( CuModuleCreateInfoNVX const & ) const = default; #else bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15197,21 +16956,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreValuesCount, + pWaitSemaphoreValues, + signalSemaphoreValuesCount, + pSignalSemaphoreValues ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default; # else bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && - ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -15298,18 +17073,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pMarkerName, color ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default; #else bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) && - ( color == rhs.color ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15404,18 +17191,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, pObjectName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( object == rhs.object ) && ( pObjectName == rhs.pObjectName ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15553,19 +17353,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && - ( pTag == rhs.pTag ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15665,18 +17479,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default; #else bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15761,18 +17588,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pLabelName, color ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsLabelEXT const & ) const = default; #else bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) && - ( color == rhs.color ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -15866,18 +17705,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, pObjectName ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16099,22 +17951,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pMessageIdName, + messageIdNumber, + pMessage, + queueLabelCount, + pQueueLabels, + cmdBufLabelCount, + pCmdBufLabels, + objectCount, + pObjects ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16237,19 +18116,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default; #else bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) && - ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16388,19 +18281,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default; #else bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && - ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && - ( pTag == rhs.pTag ); + return this->reflect() == rhs.reflect(); } bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16484,17 +18391,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16575,17 +18492,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16677,17 +18604,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default; #else bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16793,19 +18733,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier2KHR const & ) const = default; #else bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( dstAccessMask == rhs.dstAccessMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -16905,19 +18858,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSubresourceRange const & ) const = default; #else bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && - ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) && - ( layerCount == rhs.layerCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17068,22 +19033,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcStageMask, + srcAccessMask, + dstStageMask, + dstAccessMask, + oldLayout, + newLayout, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + image, + subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default; #else bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17274,22 +19266,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DependencyInfoKHR const & ) const = default; #else bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17377,17 +19390,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset, range ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorBufferInfo const & ) const = default; #else bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17465,17 +19490,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sampler, imageView, imageLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorImageInfo const & ) const = default; #else bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17543,17 +19580,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, descriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolSize const & ) const = default; #else bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17669,18 +19716,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolCreateInfo const & ) const = default; #else bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) && - ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17766,18 +19827,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInlineUniformBlockBindings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default; #else bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -17896,18 +19966,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && - ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18037,19 +20120,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBinding const & ) const = default; #else bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && - ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) && - ( pImmutableSamplers == rhs.pImmutableSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18156,18 +20251,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bindingCount, pBindingFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && - ( pBindingFlags == rhs.pBindingFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18287,18 +20394,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, bindingCount, pBindings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default; #else bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18362,17 +20482,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supported ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18483,18 +20613,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) && - ( pDescriptorCounts == rhs.pDescriptorCounts ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18566,18 +20708,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVariableDescriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default; #else bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18691,19 +20842,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default; #else bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && - ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && - ( offset == rhs.offset ) && ( stride == rhs.stride ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18878,21 +21042,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + descriptorUpdateEntryCount, + pDescriptorUpdateEntries, + templateType, + descriptorSetLayout, + pipelineBindPoint, + pipelineLayout, + set ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default; #else bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -18981,17 +21169,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19114,19 +21314,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueCreateInfo const & ) const = default; #else bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) && - ( pQueuePriorities == rhs.pQueuePriorities ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19681,56 +21894,135 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( robustBufferAccess, + fullDrawIndexUint32, + imageCubeArray, + independentBlend, + geometryShader, + tessellationShader, + sampleRateShading, + dualSrcBlend, + logicOp, + multiDrawIndirect, + drawIndirectFirstInstance, + depthClamp, + depthBiasClamp, + fillModeNonSolid, + depthBounds, + wideLines, + largePoints, + alphaToOne, + multiViewport, + samplerAnisotropy, + textureCompressionETC2, + textureCompressionASTC_LDR, + textureCompressionBC, + occlusionQueryPrecise, + pipelineStatisticsQuery, + vertexPipelineStoresAndAtomics, + fragmentStoresAndAtomics, + shaderTessellationAndGeometryPointSize, + shaderImageGatherExtended, + shaderStorageImageExtendedFormats, + shaderStorageImageMultisample, + shaderStorageImageReadWithoutFormat, + shaderStorageImageWriteWithoutFormat, + shaderUniformBufferArrayDynamicIndexing, + shaderSampledImageArrayDynamicIndexing, + shaderStorageBufferArrayDynamicIndexing, + shaderStorageImageArrayDynamicIndexing, + shaderClipDistance, + shaderCullDistance, + shaderFloat64, + shaderInt64, + shaderInt16, + shaderResourceResidency, + shaderResourceMinLod, + sparseBinding, + sparseResidencyBuffer, + sparseResidencyImage2D, + sparseResidencyImage3D, + sparseResidency2Samples, + sparseResidency4Samples, + sparseResidency8Samples, + sparseResidency16Samples, + sparseResidencyAliased, + variableMultisampleRate, + inheritedQueries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures const & ) const = default; #else bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -19965,21 +22257,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + queueCreateInfoCount, + pQueueCreateInfos, + enabledLayerCount, + ppEnabledLayerNames, + enabledExtensionCount, + ppEnabledExtensionNames, + pEnabledFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceCreateInfo const & ) const = default; #else bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20084,18 +22400,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnUserCallback, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default; #else bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20177,17 +22506,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default; #else bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20265,17 +22606,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceEvent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceEventInfoEXT const & ) const = default; #else bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20359,18 +22712,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default; #else bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) && - ( memoryDeviceIndex == rhs.memoryDeviceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20450,17 +22812,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default; #else bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20568,18 +22940,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default; #else bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( pPhysicalDevices == rhs.pPhysicalDevices ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20648,18 +23032,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentMask, modes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default; #else bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && - ( modes == rhs.modes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20777,18 +23173,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default; #else bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -20907,18 +23316,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default; #else bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && - ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21090,22 +23512,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphoreDeviceIndices, + commandBufferCount, + pCommandBufferDeviceMasks, + signalSemaphoreCount, + pSignalSemaphoreDeviceIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSubmitInfo const & ) const = default; #else bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21188,17 +23629,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, modes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21419,22 +23872,55 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + imageType, + format, + extent, + mipLevels, + arrayLayers, + samples, + tiling, + usage, + sharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + initialLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCreateInfo const & ) const = default; #else bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21533,18 +24019,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default; #else bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && - ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21626,17 +24124,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default; #else bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21721,18 +24231,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, overallocationBehavior ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default; #else bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( overallocationBehavior == rhs.overallocationBehavior ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21812,19 +24333,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; #else bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -21910,18 +24447,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateDataSlotRequestCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default; #else bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22004,17 +24550,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default; #else bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22107,18 +24665,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DeviceQueueInfo2 const & ) const = default; #else bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22212,18 +24783,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dfb, surface ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && - ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -22307,17 +24891,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DispatchIndirectCommand const & ) const = default; #else bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); + return this->reflect() == rhs.reflect(); } bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22388,17 +24982,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayEvent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayEventInfoEXT const & ) const = default; #else bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22471,17 +25077,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( visibleRegion, refreshRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeParametersKHR const & ) const = default; #else bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22559,18 +25175,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, parameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default; #else bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( parameters == rhs.parameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22631,17 +25259,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( displayMode, parameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModePropertiesKHR const & ) const = default; #else bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22696,17 +25334,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayModeProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayModeProperties2KHR const & ) const = default; #else bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22772,17 +25422,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingSupport ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default; #else bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22859,21 +25519,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( supportedAlpha, + minSrcPosition, + maxSrcPosition, + minSrcExtent, + maxSrcExtent, + minDstPosition, + maxDstPosition, + minDstExtent, + maxDstExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -22936,17 +25618,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, capabilities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default; #else bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23030,18 +25724,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode, planeIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default; #else bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && - ( planeIndex == rhs.planeIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23101,17 +25807,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( currentDisplay, currentStackIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default; #else bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23166,18 +25882,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayPlaneProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default; #else bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( displayPlaneProperties == rhs.displayPlaneProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23253,17 +25980,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, powerState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPowerInfoEXT const & ) const = default; #else bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23355,18 +26094,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcRect, dstRect, persistent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPresentInfoKHR const & ) const = default; #else bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && - ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23437,20 +26189,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( display, + displayName, + physicalDimensions, + physicalResolution, + supportedTransforms, + planeReorderPossible, + persistentContent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayPropertiesKHR const & ) const = default; #else bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( display == rhs.display ) && ( displayName == rhs.displayName ) && - ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) && - ( supportedTransforms == rhs.supportedTransforms ) && - ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23508,17 +26279,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplayProperties2KHR const & ) const = default; #else bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23657,20 +26440,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default; #else bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23778,19 +26578,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndexedIndirectCommand const & ) const = default; #else bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) && - ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) && - ( firstInstance == rhs.firstInstance ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23875,18 +26683,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( vertexCount, instanceCount, firstVertex, firstInstance ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawIndirectCommand const & ) const = default; #else bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) && - ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -23955,17 +26772,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( taskCount, firstTask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default; #else bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24023,19 +26850,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default; #else bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24094,19 +26929,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24177,19 +27020,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24267,19 +27121,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default; #else bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24356,17 +27221,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( EventCreateInfo const & ) const = default; #else bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24441,17 +27318,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceCreateInfo const & ) const = default; #else bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24545,18 +27434,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -24636,17 +27538,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfo const & ) const = default; #else bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24724,17 +27638,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default; #else bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -24828,18 +27754,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -24929,18 +27868,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -25020,17 +27971,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default; #else bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25126,18 +28089,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && - ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -25201,17 +28177,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( extensionName, specVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExtensionProperties const & ) const = default; #else bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25265,19 +28251,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryProperties const & ) const = default; #else bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25333,18 +28329,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalBufferProperties const & ) const = default; #else bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( externalMemoryProperties == rhs.externalMemoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25410,20 +28417,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFenceProperties const & ) const = default; #else bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && - ( externalFenceFeatures == rhs.externalFenceFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25501,17 +28519,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormat ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalFormatANDROID const & ) const = default; # else bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -25574,18 +28602,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatProperties const & ) const = default; #else bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( externalMemoryProperties == rhs.externalMemoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25653,19 +28692,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties const & ) const = default; #else bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) && - ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) && - ( maxResourceSize == rhs.maxResourceSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25726,20 +28777,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default; #else bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( imageFormatProperties == rhs.imageFormatProperties ) && - ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25813,17 +28875,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25903,17 +28977,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -25993,17 +29079,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default; #else bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26070,20 +29168,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ExternalSemaphoreProperties const & ) const = default; #else bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && - ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26162,17 +29271,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceCreateInfo const & ) const = default; #else bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26256,18 +29377,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetFdInfoKHR const & ) const = default; #else bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26356,18 +29489,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -26439,18 +29584,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterCubic, filterCubicMinmax ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default; #else bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && - ( filterCubicMinmax == rhs.filterCubicMinmax ); + return this->reflect() == rhs.reflect(); } bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26515,18 +29672,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties const & ) const = default; #else bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( linearTilingFeatures == rhs.linearTilingFeatures ) && - ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26580,17 +29748,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties2 const & ) const = default; #else bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26655,18 +29834,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FormatProperties3KHR const & ) const = default; #else bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) && - ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26756,19 +29948,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -26928,19 +30131,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default; #else bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27055,19 +30274,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default; #else bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) && - ( pAttachmentImageInfos == rhs.pAttachmentImageInfos ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27224,20 +30454,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferCreateInfo const & ) const = default; #else bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27314,20 +30559,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default; #else bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( coverageReductionMode == rhs.coverageReductionMode ) && - ( rasterizationSamples == rhs.rasterizationSamples ) && - ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27407,17 +30664,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsStreamNV const & ) const = default; #else bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27634,25 +30901,55 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pipelineBindPoint, + pipeline, + indirectCommandsLayout, + streamCount, + pStreams, + sequencesCount, + preprocessBuffer, + preprocessOffset, + preprocessSize, + sequencesCountBuffer, + sequencesCountOffset, + sequencesIndexBuffer, + sequencesIndexOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27774,19 +31071,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default; #else bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && - ( maxSequencesCount == rhs.maxSequencesCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27877,17 +31187,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, stride, inputRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription const & ) const = default; #else bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -27975,18 +31295,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( location, binding, format, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription const & ) const = default; #else bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && - ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28136,21 +31465,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + vertexBindingDescriptionCount, + pVertexBindingDescriptions, + vertexAttributeDescriptionCount, + pVertexAttributeDescriptions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default; #else bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) && - ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) && - ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) && - ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28253,18 +31600,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, topology, primitiveRestartEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default; #else bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28356,18 +31716,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, patchControlPoints ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( patchControlPoints == rhs.patchControlPoints ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28518,19 +31890,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default; #else bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) && - ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28704,23 +32090,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthClampEnable, + rasterizerDiscardEnable, + polygonMode, + cullMode, + frontFace, + depthBiasEnable, + depthBiasConstantFactor, + depthBiasClamp, + depthBiasSlopeFactor, + lineWidth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default; #else bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -28865,21 +32279,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + rasterizationSamples, + sampleShadingEnable, + minSampleShading, + pSampleMask, + alphaToCoverageEnable, + alphaToOneEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default; #else bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29002,19 +32438,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StencilOpState const & ) const = default; #else bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) && - ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) && - ( reference == rhs.reference ); + return this->reflect() == rhs.reflect(); } bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29172,21 +32622,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthTestEnable, + depthWriteEnable, + depthCompareOp, + depthBoundsTestEnable, + stencilTestEnable, + front, + back, + minDepthBounds, + maxDepthBounds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default; #else bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29328,20 +32806,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( blendEnable, + srcColorBlendFactor, + dstColorBlendFactor, + colorBlendOp, + srcAlphaBlendFactor, + dstAlphaBlendFactor, + alphaBlendOp, + colorWriteMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default; #else bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29493,20 +32992,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default; #else bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29629,18 +33142,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default; #else bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -29912,25 +33438,63 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + pVertexInputState, + pInputAssemblyState, + pTessellationState, + pViewportState, + pRasterizationState, + pMultisampleState, + pDepthStencilState, + pColorBlendState, + pDynamicState, + layout, + renderPass, + subpass, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default; #else bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30074,19 +33638,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && - ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) && - ( pTessellationState == rhs.pTessellationState ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30234,18 +33811,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default; #else bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && - ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines ); + return this->reflect() == rhs.reflect(); } bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30322,17 +33913,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XYColorEXT const & ) const = default; #else bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ); + return this->reflect() == rhs.reflect(); } bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30459,21 +34060,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + displayPrimaryRed, + displayPrimaryGreen, + displayPrimaryBlue, + whitePoint, + maxLuminance, + minLuminance, + maxContentLightLevel, + maxFrameAverageLightLevel ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HdrMetadataEXT const & ) const = default; #else bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30555,17 +34180,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default; #else bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30650,17 +34287,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); + return this->reflect() == rhs.reflect(); } bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -30755,18 +34405,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageBlit const & ) const = default; #else bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -30885,20 +34547,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + imageCreateInfo, + requiredFormatFeatures, + flags, + sysmemPixelFormat, + colorSpaceCount, + pColorSpaces ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -31035,20 +34718,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default; # else bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( formatConstraintsCount == rhs.formatConstraintsCount ) && - ( pFormatConstraints == rhs.pFormatConstraints ) && - ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -31153,18 +34848,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageCopy const & ) const = default; #else bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31224,18 +34932,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, size, rowPitch, arrayPitch, depthPitch ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubresourceLayout const & ) const = default; #else bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) && - ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31353,19 +35074,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( pPlaneLayouts == rhs.pPlaneLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31478,19 +35211,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31557,17 +35301,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default; #else bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31672,18 +35426,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewFormatCount, pViewFormats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatListCreateInfo const & ) const = default; #else bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && - ( pViewFormats == rhs.pViewFormats ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31746,17 +35512,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFormatProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageFormatProperties2 const & ) const = default; #else bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31895,21 +35673,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcAccessMask, + dstAccessMask, + oldLayout, + newLayout, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + image, + subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryBarrier const & ) const = default; #else bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -31991,17 +35793,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32092,18 +35904,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, imagePipeHandle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default; # else bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -32185,17 +36009,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default; #else bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32299,18 +36135,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve const & ) const = default; #else bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32416,19 +36265,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageResolve2KHR const & ) const = default; #else bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && - ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32511,17 +36374,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default; #else bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32600,17 +36473,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilUsage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default; #else bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32689,17 +36574,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default; #else bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32777,17 +36674,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default; #else bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32852,18 +36759,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default; #else bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && - ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -32984,19 +36903,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewCreateInfo const & ) const = default; #else bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33094,18 +37028,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, descriptorType, sampler ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewHandleInfoNVX const & ) const = default; #else bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33180,17 +37127,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default; #else bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33267,17 +37224,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImageViewUsageCreateInfo const & ) const = default; #else bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33360,17 +37329,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -33474,18 +37453,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceFdInfoKHR const & ) const = default; #else bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && - ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33602,18 +37595,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && - ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -33709,18 +37717,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && - ( index == rhs.index ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -33807,17 +37827,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default; #else bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -33905,18 +37938,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, pHostPointer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default; #else bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( pHostPointer == rhs.pHostPointer ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34015,18 +38060,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ) && ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -34118,18 +38176,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default; # else bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -34222,18 +38292,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -34340,18 +38422,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, fd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default; #else bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -34470,19 +38566,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, handle, name ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default; # else bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && - ( name == rhs.name ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -34599,19 +38709,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -34865,24 +38988,55 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tokenType, + stream, + offset, + vertexBindingUnit, + vertexDynamicStride, + pushconstantPipelineLayout, + pushconstantShaderStageFlags, + pushconstantOffset, + pushconstantSize, + indirectStateFlags, + indexTypeCount, + pIndexTypes, + pIndexTypeValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35058,20 +39212,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default; #else bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35154,17 +39322,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pUserData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default; #else bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData ); + return this->reflect() == rhs.reflect(); } bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35251,18 +39429,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpass, inputAttachmentIndex, aspectMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InputAttachmentAspectReference const & ) const = default; #else bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) && - ( aspectMask == rhs.aspectMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35414,21 +39601,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pApplicationInfo, + enabledLayerCount, + ppEnabledLayerNames, + enabledExtensionCount, + ppEnabledExtensionNames ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( InstanceCreateInfo const & ) const = default; #else bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35496,18 +39703,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( layerName, specVersion, implementationVersion, description ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( LayerProperties const & ) const = default; #else bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) && - ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description ); + return this->reflect() == rhs.reflect(); } bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35586,17 +39805,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default; # else bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); + return this->reflect() == rhs.reflect(); } bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -35690,18 +39922,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MappedMemoryRange const & ) const = default; #else bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && - ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35785,18 +40030,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, deviceMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default; #else bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( deviceMask == rhs.deviceMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35881,18 +40138,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryAllocateInfo const & ) const = default; #else bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && - ( memoryTypeIndex == rhs.memoryTypeIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -35976,18 +40245,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask, dstAccessMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryBarrier const & ) const = default; #else bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36072,17 +40353,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default; #else bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36149,19 +40443,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryDedicatedRequirements const & ) const = default; #else bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) && - ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36224,17 +40529,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryFdPropertiesKHR const & ) const = default; #else bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36317,17 +40632,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default; # else bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36416,18 +40743,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetFdInfoKHR const & ) const = default; #else bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36515,18 +40854,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default; #else bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36617,18 +40968,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36721,18 +41084,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -36795,17 +41170,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHeap const & ) const = default; #else bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( size == rhs.size ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36859,17 +41244,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default; #else bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -36951,17 +41346,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default; #else bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37040,17 +41445,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default; #else bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37112,17 +41527,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, alignment, memoryTypeBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements const & ) const = default; #else bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37176,17 +41601,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryRequirements2 const & ) const = default; #else bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37245,17 +41682,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( propertyFlags, heapIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryType const & ) const = default; #else bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37310,17 +41757,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default; # else bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -37387,17 +41844,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default; # else bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -37484,17 +41951,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pLayer ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default; # else bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer ); + return this->reflect() == rhs.reflect(); } bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -37577,18 +42057,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstIndex, indexCount, vertexOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default; #else bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) && - ( vertexOffset == rhs.vertexOffset ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37654,17 +42143,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstVertex, vertexCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiDrawInfoEXT const & ) const = default; #else bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37717,18 +42216,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSampleLocationGridSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultisamplePropertiesEXT const & ) const = default; #else bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37816,18 +42324,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default; #else bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) && - ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly ); + return this->reflect() == rhs.reflect(); } bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -37927,17 +42447,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( descriptorTypeCount, pDescriptorTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38041,19 +42571,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default; #else bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && - ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); + return this->reflect() == rhs.reflect(); } bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38121,19 +42662,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default; #else bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) && - ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) && - ( presentMargin == rhs.presentMargin ); + return this->reflect() == rhs.reflect(); } bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38214,17 +42763,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default; #else bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38296,18 +42857,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, name, category, description ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default; #else bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) && - ( category == rhs.category ) && ( description == rhs.description ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38380,18 +42955,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, unit, scope, storage, uuid ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceCounterKHR const & ) const = default; #else bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && - ( storage == rhs.storage ) && ( uuid == rhs.uuid ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38542,17 +43131,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38647,18 +43246,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, enable, parameter ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default; #else bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && - ( parameter == rhs.parameter ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38739,17 +43351,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, counterPassIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default; #else bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38826,17 +43448,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default; #else bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); + return this->reflect() == rhs.reflect(); } bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -38985,6 +43617,17 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, data ); + } + public: VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32; VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL data = {}; @@ -39080,21 +43723,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageBuffer16BitAccess, + uniformAndStorageBuffer16BitAccess, + storagePushConstant16, + storageInputOutput16 ); + } + #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 { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && - ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && - ( storagePushConstant16 == rhs.storagePushConstant16 ) && - ( storageInputOutput16 == rhs.storageInputOutput16 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39188,18 +43847,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && - ( formatA4B4G4R4 == rhs.formatA4B4G4R4 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39298,20 +43969,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default; #else bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && - ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && - ( storagePushConstant8 == rhs.storagePushConstant8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39395,18 +44077,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeModeSharedExponent ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39527,23 +44218,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + accelerationStructure, + accelerationStructureCaptureReplay, + accelerationStructureIndirectBuild, + accelerationStructureHostCommands, + descriptorBindingAccelerationStructureUpdateAfterBind ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructure == rhs.accelerationStructure ) && - ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) && - ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) && - ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) && - ( descriptorBindingAccelerationStructureUpdateAfterBind == - rhs.descriptorBindingAccelerationStructureUpdateAfterBind ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39631,25 +44338,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGeometryCount, + maxInstanceCount, + maxPrimitiveCount, + maxPerStageDescriptorAccelerationStructures, + maxPerStageDescriptorUpdateAfterBindAccelerationStructures, + maxDescriptorSetAccelerationStructures, + maxDescriptorSetUpdateAfterBindAccelerationStructures, + minAccelerationStructureScratchOffsetAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39741,18 +44468,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, advancedBlendCoherentOperations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39832,23 +44568,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + advancedBlendMaxColorAttachments, + advancedBlendIndependentBlend, + advancedBlendNonPremultipliedSrcColor, + advancedBlendNonPremultipliedDstColor, + advancedBlendCorrelatedOverlap, + advancedBlendAllOperations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -39946,18 +44700,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) && - ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40060,19 +44826,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40177,19 +44956,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40275,17 +45067,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceCoherentMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default; #else bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40368,17 +45170,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorWriteEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40472,19 +45284,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) && - ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40579,18 +45402,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) && - ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40677,26 +45512,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + primitiveOverestimationSize, + maxExtraPrimitiveOverestimationSize, + extraPrimitiveOverestimationSizeGranularity, + primitiveUnderestimation, + conservativePointAndLineRasterization, + degenerateTrianglesRasterized, + degenerateLinesRasterized, + fullyCoveredFragmentShaderInputVariable, + conservativeRasterizationPostDepthCoverage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40797,18 +45653,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && - ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40878,18 +45746,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -40973,17 +45851,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cornerSampledImage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41068,17 +45956,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41171,18 +46069,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) && - ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41252,18 +46162,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxCustomBorderColorSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41350,18 +46269,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocationImageAliasing ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41446,17 +46374,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipControl ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41540,17 +46478,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41625,21 +46573,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + supportedDepthResolveModes, + supportedStencilResolveModes, + independentResolveNone, + independentResolve ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default; #else bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && - ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && - ( independentResolveNone == rhs.independentResolveNone ) && - ( independentResolve == rhs.independentResolve ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -41902,41 +46866,69 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42069,52 +47061,75 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default; #else bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42222,18 +47237,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceGeneratedCommands ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42319,26 +47343,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGraphicsShaderGroupCount, + maxIndirectSequenceCount, + maxIndirectCommandsTokenCount, + maxIndirectCommandsStreamCount, + maxIndirectCommandsTokenOffset, + maxIndirectCommandsStreamStride, + minSequencesCountBufferOffsetAlignment, + minSequencesIndexBufferOffsetAlignment, + minIndirectCommandsBufferOffsetAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42430,17 +47475,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMemoryReport ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42524,17 +47579,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, diagnosticsConfig ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42603,17 +47668,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxDiscardRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42684,19 +47759,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ConformanceVersion const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default; #else bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && - ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) && - ( conformanceVersion == rhs.conformanceVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42773,20 +47861,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42873,17 +47975,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicRendering ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -42966,17 +48078,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43079,20 +48201,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && - ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && - ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43179,17 +48313,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedDynamicState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43288,18 +48432,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43383,17 +48540,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43478,17 +48647,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43558,18 +48739,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minImportedHostPointerAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43653,17 +48843,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryRDMA ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43746,17 +48946,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default; #else bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43835,17 +49047,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, features ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default; #else bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -43946,34 +49170,63 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default; #else bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44075,18 +49328,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapDeferred ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44161,20 +49423,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + subsampledLoads, + subsampledCoarseReconstructionEarlyAccess, + maxSubsampledArrayLayers, + maxDescriptorSetSubsampledSamplers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) && - ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) && - ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) && - ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44279,19 +49558,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) && - ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) && - ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44366,20 +49658,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) && - ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) && - ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44467,18 +49771,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentShaderBarycentric ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44581,20 +49894,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) && - ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) && - ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44699,20 +50024,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) && - ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) && - ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44802,18 +50139,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -44916,20 +50264,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) && - ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) && - ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45000,18 +50360,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleCounts, fragmentSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && - ( fragmentSize == rhs.fragmentSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45113,38 +50485,63 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSizeAspectRatio, + primitiveFragmentShadingRateWithMultipleViewports, + layeredShadingRateAttachments, + fragmentShadingRateNonTrivialCombinerOps, + maxFragmentSize, + maxFragmentSizeAspectRatio, + maxFragmentShadingRateCoverageSamples, + maxFragmentShadingRateRasterizationSamples, + fragmentShadingRateWithShaderDepthStencilWrites, + fragmentShadingRateWithSampleMask, + fragmentShadingRateWithShaderSampleMask, + fragmentShadingRateWithConservativeRasterization, + fragmentShadingRateWithFragmentShaderInterlock, + fragmentShadingRateWithCustomSampleLocations, + fragmentShadingRateStrictMultiplyCombiner ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45245,17 +50642,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriorityQuery ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45324,18 +50731,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple< + VULKAN_HPP_NAMESPACE::StructureType const &, + void * const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45420,17 +50841,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hostQueryReset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default; #else bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45502,19 +50933,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIDProperties const & ) const = default; #else bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && - ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) && - ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45651,19 +51096,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && - ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45782,18 +51240,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, tiling, usage, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && - ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45881,17 +51354,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustImageAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -45976,17 +51459,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageViewType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46070,17 +51563,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46164,17 +51667,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imagelessFramebuffer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default; #else bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46258,17 +51771,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indexTypeUint8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46353,18 +51876,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inheritedViewportScissor2D ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46458,19 +51990,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) && - ( descriptorBindingInlineUniformBlockUpdateAfterBind == - rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46549,24 +52092,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxInlineUniformBlockSize, + maxPerStageDescriptorInlineUniformBlocks, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, + maxDescriptorSetInlineUniformBlocks, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && - ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && - ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == - rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && - ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && - ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == - rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46653,17 +52211,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, invocationMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -46933,115 +52501,237 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + size_t const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + int32_t const &, + uint32_t const &, + int32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + float const &, + float const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxImageDimension1D, + maxImageDimension2D, + maxImageDimension3D, + maxImageDimensionCube, + maxImageArrayLayers, + maxTexelBufferElements, + maxUniformBufferRange, + maxStorageBufferRange, + maxPushConstantsSize, + maxMemoryAllocationCount, + maxSamplerAllocationCount, + bufferImageGranularity, + sparseAddressSpaceSize, + maxBoundDescriptorSets, + maxPerStageDescriptorSamplers, + maxPerStageDescriptorUniformBuffers, + maxPerStageDescriptorStorageBuffers, + maxPerStageDescriptorSampledImages, + maxPerStageDescriptorStorageImages, + maxPerStageDescriptorInputAttachments, + maxPerStageResources, + maxDescriptorSetSamplers, + maxDescriptorSetUniformBuffers, + maxDescriptorSetUniformBuffersDynamic, + maxDescriptorSetStorageBuffers, + maxDescriptorSetStorageBuffersDynamic, + maxDescriptorSetSampledImages, + maxDescriptorSetStorageImages, + maxDescriptorSetInputAttachments, + maxVertexInputAttributes, + maxVertexInputBindings, + maxVertexInputAttributeOffset, + maxVertexInputBindingStride, + maxVertexOutputComponents, + maxTessellationGenerationLevel, + maxTessellationPatchSize, + maxTessellationControlPerVertexInputComponents, + maxTessellationControlPerVertexOutputComponents, + maxTessellationControlPerPatchOutputComponents, + maxTessellationControlTotalOutputComponents, + maxTessellationEvaluationInputComponents, + maxTessellationEvaluationOutputComponents, + maxGeometryShaderInvocations, + maxGeometryInputComponents, + maxGeometryOutputComponents, + maxGeometryOutputVertices, + maxGeometryTotalOutputComponents, + maxFragmentInputComponents, + maxFragmentOutputAttachments, + maxFragmentDualSrcAttachments, + maxFragmentCombinedOutputResources, + maxComputeSharedMemorySize, + maxComputeWorkGroupCount, + maxComputeWorkGroupInvocations, + maxComputeWorkGroupSize, + subPixelPrecisionBits, + subTexelPrecisionBits, + mipmapPrecisionBits, + maxDrawIndexedIndexValue, + maxDrawIndirectCount, + maxSamplerLodBias, + maxSamplerAnisotropy, + maxViewports, + maxViewportDimensions, + viewportBoundsRange, + viewportSubPixelBits, + minMemoryMapAlignment, + minTexelBufferOffsetAlignment, + minUniformBufferOffsetAlignment, + minStorageBufferOffsetAlignment, + minTexelOffset, + maxTexelOffset, + minTexelGatherOffset, + maxTexelGatherOffset, + minInterpolationOffset, + maxInterpolationOffset, + subPixelInterpolationOffsetBits, + maxFramebufferWidth, + maxFramebufferHeight, + maxFramebufferLayers, + framebufferColorSampleCounts, + framebufferDepthSampleCounts, + framebufferStencilSampleCounts, + framebufferNoAttachmentsSampleCounts, + maxColorAttachments, + sampledImageColorSampleCounts, + sampledImageIntegerSampleCounts, + sampledImageDepthSampleCounts, + sampledImageStencilSampleCounts, + storageImageSampleCounts, + maxSampleMaskWords, + timestampComputeAndGraphics, + timestampPeriod, + maxClipDistances, + maxCullDistances, + maxCombinedClipAndCullDistances, + discreteQueuePriorities, + pointSizeRange, + lineWidthRange, + pointSizeGranularity, + lineWidthGranularity, + strictLines, + standardSampleLocations, + optimalBufferCopyOffsetAlignment, + optimalBufferCopyRowPitchAlignment, + nonCoherentAtomSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLimits const & ) const = default; #else bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47264,21 +52954,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rectangularLines, + bresenhamLines, + smoothLines, + stippledRectangularLines, + stippledBresenhamLines, + stippledSmoothLines ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47352,18 +53062,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineSubPixelPrecisionBits ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47432,18 +53151,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && - ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47527,17 +53258,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance4 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47603,17 +53344,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxBufferSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47683,18 +53434,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, heapBudget, heapUsage ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && - ( heapUsage == rhs.heapUsage ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47778,17 +53541,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryPriority ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47856,18 +53629,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) && - ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -47926,17 +53711,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48027,18 +53824,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, taskShader, meshShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && - ( meshShader == rhs.meshShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48129,30 +53938,55 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxDrawMeshTasksCount, + maxTaskWorkGroupInvocations, + maxTaskWorkGroupSize, + maxTaskTotalMemorySize, + maxTaskOutputCount, + maxMeshWorkGroupInvocations, + maxMeshWorkGroupSize, + maxMeshTotalMemorySize, + maxMeshOutputVertices, + maxMeshOutputPrimitives, + maxMeshMultiviewViewCount, + meshOutputPerVertexGranularity, + meshOutputPerPrimitiveGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48245,17 +54079,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiDraw ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48320,17 +54164,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiDrawCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48427,19 +54281,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && - ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && - ( multiviewTessellationShader == rhs.multiviewTessellationShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48511,18 +54377,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewPositionAllComponents ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48591,19 +54466,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default; #else bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && - ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48689,17 +54572,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default; #else bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48772,18 +54665,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && - ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48871,18 +54778,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pageableDeviceLocalMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -48975,19 +54891,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) && - ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49057,18 +54984,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allowCommandBufferQueryCopies ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49154,18 +55090,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineCreationCacheControl ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49252,18 +55197,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineExecutableInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49333,17 +55287,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pointClippingBehavior ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default; #else bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49555,29 +55521,59 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + constantAlphaColorBlendFactors, + events, + imageViewFormatReinterpretation, + imageViewFormatSwizzle, + imageView2DOn3DImage, + multisampleArrayImage, + mutableComparisonSamplers, + pointPolygons, + samplerMipLodBias, + separateStencilMaskRef, + shaderSampleRateInterpolationFunctions, + tessellationIsolines, + tessellationPointMode, + triangleFans, + vertexAttributeAccessBeyondStride ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -49677,18 +55673,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minVertexInputBindingStrideAlignment ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default; # else bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -49771,17 +55776,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49862,17 +55877,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentWait ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -49967,19 +55992,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) && - ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50063,17 +56099,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50142,21 +56188,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( residencyStandard2DBlockShape, + residencyStandard2DMultisampleBlockShape, + residencyStandard3DBlockShape, + residencyAlignedMipSize, + residencyNonResidentStrict ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default; #else bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) && - ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) && - ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) && - ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) && - ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50228,20 +56288,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &, + VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( apiVersion, + driverVersion, + vendorID, + deviceID, + deviceType, + deviceName, + pipelineCacheUUID, + limits, + sparseProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties const & ) const = default; #else bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50303,17 +56386,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProperties2 const & ) const = default; #else bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50395,17 +56490,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50472,17 +56577,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedNoFault ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default; #else bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50575,18 +56690,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) && - ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50658,20 +56785,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) && - ( transformFeedbackPreservesTriangleFanProvokingVertex == - rhs.transformFeedbackPreservesTriangleFanProvokingVertex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50741,17 +56879,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPushDescriptors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50835,18 +56983,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -50954,20 +57111,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rasterizationOrderColorAttachmentAccess, + rasterizationOrderDepthAttachmentAccess, + rasterizationOrderStencilAttachmentAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default; #else bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) && - ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) && - ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51053,17 +57225,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayQuery ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51156,18 +57338,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) && - ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51290,23 +57484,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rayTracingPipeline, + rayTracingPipelineShaderGroupHandleCaptureReplay, + rayTracingPipelineShaderGroupHandleCaptureReplayMixed, + rayTracingPipelineTraceRaysIndirect, + rayTraversalPrimitiveCulling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplay == - rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed == - rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) && - ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) && - ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51393,25 +57603,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRayRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + shaderGroupHandleCaptureReplaySize, + maxRayDispatchInvocationCount, + shaderGroupHandleAlignment, + maxRayHitAttributeSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51499,23 +57729,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + maxGeometryCount, + maxInstanceCount, + maxTriangleCount, + maxDescriptorSetAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51607,18 +57859,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTest ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( representativeFragmentTest == rhs.representativeFragmentTest ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51718,18 +57979,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) && - ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51800,19 +58074,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) && - ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51890,22 +58175,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + sampleLocationSampleCounts, + maxSampleLocationGridSize, + sampleLocationCoordinateRange, + sampleLocationSubPixelBits, + variableSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) && - ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) && - ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) && - ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) && - ( variableSampleLocations == rhs.variableSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -51980,19 +58282,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default; #else bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && - ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52078,18 +58391,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, samplerYcbcrConversion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52172,17 +58494,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, scalarBlockLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52269,18 +58601,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, separateDepthStencilLayouts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default; #else bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52464,29 +58805,53 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat16Atomics, + shaderBufferFloat16AtomicAdd, + shaderBufferFloat16AtomicMinMax, + shaderBufferFloat32AtomicMinMax, + shaderBufferFloat64AtomicMinMax, + shaderSharedFloat16Atomics, + shaderSharedFloat16AtomicAdd, + shaderSharedFloat16AtomicMinMax, + shaderSharedFloat32AtomicMinMax, + shaderSharedFloat64AtomicMinMax, + shaderImageFloat32AtomicMinMax, + sparseImageFloat32AtomicMinMax ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52680,29 +59045,53 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat32Atomics, + shaderBufferFloat32AtomicAdd, + shaderBufferFloat64Atomics, + shaderBufferFloat64AtomicAdd, + shaderSharedFloat32Atomics, + shaderSharedFloat32AtomicAdd, + shaderSharedFloat64Atomics, + shaderSharedFloat64AtomicAdd, + shaderImageFloat32Atomics, + shaderImageFloat32AtomicAdd, + sparseImageFloat32Atomics, + sparseImageFloat32AtomicAdd ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52805,19 +59194,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && - ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52910,18 +59310,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) && - ( shaderDeviceClock == rhs.shaderDeviceClock ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -52991,18 +59403,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) && - ( activeComputeUnitCount == rhs.activeComputeUnitCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53097,25 +59521,57 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderEngineCount, + shaderArraysPerEngineCount, + computeUnitsPerShaderArray, + simdPerComputeUnit, + wavefrontsPerSimd, + wavefrontSize, + sgprsPerSimd, + minSgprAllocation, + maxSgprAllocation, + sgprAllocationGranularity, + vgprsPerSimd, + minVgprAllocation, + maxVgprAllocation, + vgprAllocationGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default; #else bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53213,18 +59669,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDemoteToHelperInvocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53309,17 +59774,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDrawParameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53412,18 +59887,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat16, shaderInt8 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default; #else bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && - ( shaderInt8 == rhs.shaderInt8 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53520,19 +60007,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) && - ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53616,17 +60114,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFootprint ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -53711,18 +60219,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerDotProduct ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54146,68 +60663,89 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + integerDotProduct8BitUnsignedAccelerated, + integerDotProduct8BitSignedAccelerated, + integerDotProduct8BitMixedSignednessAccelerated, + integerDotProduct4x8BitPackedUnsignedAccelerated, + integerDotProduct4x8BitPackedSignedAccelerated, + integerDotProduct4x8BitPackedMixedSignednessAccelerated, + integerDotProduct16BitUnsignedAccelerated, + integerDotProduct16BitSignedAccelerated, + integerDotProduct16BitMixedSignednessAccelerated, + integerDotProduct32BitUnsignedAccelerated, + integerDotProduct32BitSignedAccelerated, + integerDotProduct32BitMixedSignednessAccelerated, + integerDotProduct64BitUnsignedAccelerated, + integerDotProduct64BitSignedAccelerated, + integerDotProduct64BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating8BitSignedAccelerated, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating16BitSignedAccelerated, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating32BitSignedAccelerated, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating64BitSignedAccelerated, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54322,18 +60860,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerFunctions2 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default; #else bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54416,17 +60963,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMBuiltins ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54497,18 +61054,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && - ( shaderWarpsPerSM == rhs.shaderWarpsPerSM ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54595,18 +61161,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupExtendedTypes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54695,18 +61270,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupUniformControlFlow ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54794,18 +61378,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderTerminateInvocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54898,18 +61491,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) && - ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -54983,19 +61588,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default; #else bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) && - ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) && - ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55115,18 +61732,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, samples, usage, tiling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default; #else bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && - ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55201,19 +61833,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && - ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) && - ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55308,18 +61953,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) && - ( computeFullSubgroups == rhs.computeFullSubgroups ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55395,20 +62052,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && - ( maxSubgroupSize == rhs.maxSubgroupSize ) && - ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && - ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55494,17 +62164,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subpassShading ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55573,18 +62253,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default; #else bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55664,17 +62353,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surface ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default; #else bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55756,17 +62456,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, synchronization2 ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55851,17 +62561,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, texelBufferAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -55936,21 +62656,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageTexelBufferOffsetAlignmentBytes, + storageTexelBufferOffsetSingleTexelAlignment, + uniformTexelBufferOffsetAlignmentBytes, + uniformTexelBufferOffsetSingleTexelAlignment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && - ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && - ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && - ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56039,18 +62775,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureCompressionASTC_HDR ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56132,17 +62877,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timelineSemaphore ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56211,18 +62966,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default; #else bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56296,18 +63060,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, version, purposes, description, layer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) && - ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56403,18 +63182,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transformFeedback, geometryStreams ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && - ( geometryStreams == rhs.geometryStreams ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56502,27 +63293,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxTransformFeedbackStreams, + maxTransformFeedbackBuffers, + maxTransformFeedbackBufferSize, + maxTransformFeedbackStreamDataSize, + maxTransformFeedbackBufferDataSize, + maxTransformFeedbackBufferDataStride, + transformFeedbackQueries, + transformFeedbackStreamsLinesTriangles, + transformFeedbackRasterizationStreamSelect, + transformFeedbackDraw ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56617,18 +63430,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, uniformBufferStandardLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default; #else bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56721,19 +63543,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && - ( variablePointers == rhs.variablePointers ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56831,19 +63664,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && - ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -56914,18 +63758,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVertexAttribDivisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57010,18 +63863,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexInputDynamicState ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexInputDynamicState == rhs.vertexInputDynamicState ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57128,19 +63990,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfileKHR const & ) const = default; # else bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && - ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && - ( chromaBitDepth == rhs.chromaBitDepth ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -57229,18 +64104,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, profileCount, pProfiles ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoProfilesKHR const & ) const = default; # else bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && - ( pProfiles == rhs.pProfiles ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -57307,18 +64194,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageUsage, pVideoProfiles ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default; # else bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) && - ( pVideoProfiles == rhs.pVideoProfiles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -57498,27 +64397,53 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageBuffer16BitAccess, + uniformAndStorageBuffer16BitAccess, + storagePushConstant16, + storageInputOutput16, + multiview, + multiviewGeometryShader, + multiviewTessellationShader, + variablePointersStorageBuffer, + variablePointers, + protectedMemory, + samplerYcbcrConversion, + shaderDrawParameters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -57622,27 +64547,59 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ShaderStageFlags const &, + VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::PointClippingBehavior const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::DeviceSize const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + deviceUUID, + driverUUID, + deviceLUID, + deviceNodeMask, + deviceLUIDValid, + subgroupSize, + subgroupSupportedStages, + subgroupSupportedOperations, + subgroupQuadOperationsInAllStages, + pointClippingBehavior, + maxMultiviewViewCount, + maxMultiviewInstanceIndex, + protectedNoFault, + maxPerSetDescriptors, + maxMemoryAllocationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58150,64 +65107,123 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + samplerMirrorClampToEdge, + drawIndirectCount, + storageBuffer8BitAccess, + uniformAndStorageBuffer8BitAccess, + storagePushConstant8, + shaderBufferInt64Atomics, + shaderSharedInt64Atomics, + shaderFloat16, + shaderInt8, + descriptorIndexing, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray, + samplerFilterMinmax, + scalarBlockLayout, + imagelessFramebuffer, + uniformBufferStandardLayout, + shaderSubgroupExtendedTypes, + separateDepthStencilLayouts, + hostQueryReset, + timelineSemaphore, + bufferDeviceAddress, + bufferDeviceAddressCaptureReplay, + bufferDeviceAddressMultiDevice, + vulkanMemoryModel, + vulkanMemoryModelDeviceScope, + vulkanMemoryModelAvailabilityVisibilityChains, + shaderOutputViewportIndex, + shaderOutputLayer, + subgroupBroadcastDynamicId ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58421,80 +65437,133 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::ConformanceVersion const &, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &, + VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + VULKAN_HPP_NAMESPACE::ResolveModeFlags const &, + VULKAN_HPP_NAMESPACE::ResolveModeFlags const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + uint64_t const &, + VULKAN_HPP_NAMESPACE::SampleCountFlags const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + driverID, + driverName, + driverInfo, + conformanceVersion, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments, + supportedDepthResolveModes, + supportedStencilResolveModes, + independentResolveNone, + independentResolve, + filterMinmaxSingleComponentFormats, + filterMinmaxImageComponentMapping, + maxTimelineSemaphoreValueDifference, + framebufferIntegerColorSampleCounts ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default; #else bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58647,19 +65716,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default; #else bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && - ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && - ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58778,21 +65860,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + workgroupMemoryExplicitLayout, + workgroupMemoryExplicitLayoutScalarBlockLayout, + workgroupMemoryExplicitLayout8BitAccess, + workgroupMemoryExplicitLayout16BitAccess ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) && - ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) && - ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) && - ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58881,17 +65979,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcr2plane444Formats ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -58974,17 +66082,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcrImageArrays ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default; #else bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59071,18 +66189,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default; #else bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ); + return this->reflect() == rhs.reflect(); } bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59195,18 +66322,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheCreateInfo const & ) const = default; #else bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59311,19 +66451,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default; #else bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && - ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( pipelineCacheUUID == rhs.pipelineCacheUUID ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59423,18 +66575,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && - ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59544,18 +66709,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pColorWriteEnables ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default; #else bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && - ( pColorWriteEnables == rhs.pColorWriteEnables ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59637,17 +66814,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compilerControlFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default; #else bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59792,21 +66981,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + coverageModulationMode, + coverageModulationTableEnable, + coverageModulationTableCount, + pCoverageModulationTable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageModulationMode == rhs.coverageModulationMode ) && - ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) && - ( coverageModulationTableCount == rhs.coverageModulationTableCount ) && - ( pCoverageModulationTable == rhs.pCoverageModulationTable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -59906,18 +67113,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageReductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageReductionMode == rhs.coverageReductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60022,19 +67241,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( coverageToColorEnable == rhs.coverageToColorEnable ) && - ( coverageToColorLocation == rhs.coverageToColorLocation ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60099,17 +67330,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, duration ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( flags == rhs.flags ) && ( duration == rhs.duration ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60224,20 +67465,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default; #else bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) && - ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) && - ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60374,19 +67627,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( discardRectangleMode == rhs.discardRectangleMode ) && - ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60477,18 +67743,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline, executableIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInfoKHR const & ) const = default; #else bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && - ( executableIndex == rhs.executableIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60578,19 +67856,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::Bool32 const &, + size_t const &, + void * const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, isText, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default; #else bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && - ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && - ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60665,18 +67957,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + uint32_t const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stages, name, description, subgroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default; #else bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) && - ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -60815,6 +68121,21 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &, + VULKAN_HPP_NAMESPACE::ArrayWrapper1D const &, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &, + VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, format, value ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR; void * pNext = {}; @@ -60921,18 +68242,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps ); + } + #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 { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && - ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61032,18 +68366,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentSize, combinerOps ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default; #else bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && - ( combinerOps == rhs.combinerOps ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61121,17 +68467,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineInfoKHR const & ) const = default; #else bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61212,17 +68569,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( stageFlags, offset, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PushConstantRange const & ) const = default; #else bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61363,20 +68730,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLayoutCreateInfo const & ) const = default; #else bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) && - ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && - ( pPushConstantRanges == rhs.pPushConstantRanges ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61483,18 +68863,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, libraryCount, pLibraries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default; #else bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && - ( pLibraries == rhs.pLibraries ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61599,19 +68991,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) && - ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61708,18 +69112,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, depthClipEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( depthClipEnable == rhs.depthClipEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61833,20 +69249,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( lineRasterizationMode == rhs.lineRasterizationMode ) && - ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) && - ( lineStipplePattern == rhs.lineStipplePattern ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -61937,17 +69365,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62035,17 +69475,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rasterizationOrder ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default; #else bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62140,18 +69592,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rasterizationStream ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default; #else bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( rasterizationStream == rhs.rasterizationStream ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62293,21 +69757,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + viewMask, + colorAttachmentCount, + pColorAttachmentFormats, + depthAttachmentFormat, + stencilAttachmentFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default; #else bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && - ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && - ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62396,18 +69878,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTestEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62501,19 +69992,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sampleLocationsEnable == rhs.sampleLocationsEnable ) && - ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62584,17 +70086,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, requiredSubgroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default; #else bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62679,17 +70191,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, domainOrigin ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default; #else bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62772,17 +70296,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, divisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default; #else bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( binding == rhs.binding ) && ( divisor == rhs.divisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -62892,19 +70426,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default; #else bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) && - ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63032,19 +70577,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) && - ( customSampleOrderCount == rhs.customSampleOrderCount ) && - ( pCustomSampleOrders == rhs.pCustomSampleOrders ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63131,17 +70688,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, negativeOneToOne ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default; #else bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63255,18 +70822,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63365,18 +70944,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShadingRatePaletteNV const & ) const = default; #else bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) && - ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63492,19 +71080,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) && - ( pShadingRatePalettes == rhs.pShadingRatePalettes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63606,17 +71206,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z, w ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportSwizzleNV const & ) const = default; #else bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63733,18 +71346,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63820,17 +71446,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( xcoeff, ycoeff ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViewportWScalingNV const & ) const = default; #else bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -63945,19 +71581,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default; #else bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) && - ( pViewportWScalings == rhs.pViewportWScalings ); + return this->reflect() == rhs.reflect(); } bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64036,18 +71684,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, frameToken ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentFrameTokenGGP const & ) const = default; # else bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -64145,18 +71802,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pPresentIds ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentIdKHR const & ) const = default; #else bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pPresentIds == rhs.pPresentIds ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64353,20 +72022,35 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentInfoKHR const & ) const = default; #else bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64457,17 +72141,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent, layer ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RectLayerKHR const & ) const = default; #else bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer ); + return this->reflect() == rhs.reflect(); } bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64553,17 +72247,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rectangleCount, pRectangles ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionKHR const & ) const = default; #else bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64657,18 +72361,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentRegionsKHR const & ) const = default; #else bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pRegions == rhs.pRegions ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64742,17 +72458,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimeGOOGLE const & ) const = default; #else bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64846,18 +72572,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pTimes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default; #else bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && - ( pTimes == rhs.pTimes ); + return this->reflect() == rhs.reflect(); } bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -64934,17 +72672,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default; #else bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65020,17 +72770,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedSubmit ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ProtectedSubmitInfo const & ) const = default; #else bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit ); + return this->reflect() == rhs.reflect(); } bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65131,19 +72891,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolCreateInfo const & ) const = default; #else bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) && - ( pipelineStatistics == rhs.pipelineStatistics ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65261,18 +73034,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default; #else bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65359,18 +73145,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCountersSampling ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default; #else bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( performanceCountersSampling == rhs.performanceCountersSampling ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65439,18 +73236,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default; #else bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65515,18 +73323,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default; #else bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65634,18 +73453,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priorityCount, priorities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default; #else bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && - ( priorities == rhs.priorities ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65713,19 +73545,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties const & ) const = default; #else bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) && - ( timestampValidBits == rhs.timestampValidBits ) && - ( minImageTransferGranularity == rhs.minImageTransferGranularity ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65780,17 +73623,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyProperties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( QueueFamilyProperties2 const & ) const = default; #else bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties ); + return this->reflect() == rhs.reflect(); } bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -65917,20 +73772,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + type, + generalShader, + closestHitShader, + anyHitShader, + intersectionShader, + pShaderGroupCaptureReplayHandle ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66029,19 +73905,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) && - ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66270,22 +74154,53 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + groupCount, + pGroups, + maxPipelineRayRecursionDepth, + pLibraryInfo, + pLibraryInterface, + pDynamicState, + layout, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66413,19 +74328,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default; #else bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && - ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) && - ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66624,20 +74553,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + groupCount, + pGroups, + maxRecursionDepth, + layout, + basePipelineHandle, + basePipelineIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default; #else bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66704,17 +74660,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( refreshDuration ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default; #else bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( refreshDuration == rhs.refreshDuration ); + return this->reflect() == rhs.reflect(); } bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66811,18 +74777,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default; #else bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && - ( pAttachments == rhs.pAttachments ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -66961,19 +74939,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassBeginInfo const & ) const = default; #else bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && - ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) && - ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67203,23 +75195,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, + pipelineBindPoint, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription const & ) const = default; #else bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67338,20 +75352,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency const & ) const = default; #else bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && - ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) && - ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && - ( dependencyFlags == rhs.dependencyFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67527,20 +75555,36 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo const & ) const = default; #else bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67791,24 +75835,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pipelineBindPoint, + viewMask, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescription2 const & ) const = default; #else bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -67953,21 +76024,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcSubpass, + dstSubpass, + srcStageMask, + dstStageMask, + srcAccessMask, + dstAccessMask, + dependencyFlags, + viewOffset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDependency2 const & ) const = default; #else bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68183,22 +76278,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + attachmentCount, + pAttachments, + subpassCount, + pSubpasses, + dependencyCount, + pDependencies, + correlatedViewMaskCount, + pCorrelatedViewMasks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassCreateInfo2 const & ) const = default; #else bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68289,18 +76409,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default; #else bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68414,18 +76545,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default; #else bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) && - ( pAspectReferences == rhs.pAspectReferences ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68595,20 +76738,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + subpassCount, + pViewMasks, + dependencyCount, + pViewOffsets, + correlationMaskCount, + pCorrelationMasks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default; #else bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68691,17 +76855,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpassIndex, sampleLocationsInfo ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassSampleLocationsEXT const & ) const = default; #else bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68838,21 +77012,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + attachmentInitialSampleLocationsCount, + pAttachmentInitialSampleLocations, + postSubpassSampleLocationsCount, + pPostSubpassSampleLocations ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default; #else bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) && - ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) && - ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) && - ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -68934,17 +77124,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default; #else bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69086,6 +77288,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + imageView, + imageLayout, + resolveMode, + resolveImageView, + resolveImageLayout, + loadOp, + storeOp, + clearValue ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderingAttachmentInfoKHR; const void * pNext = {}; @@ -69182,18 +77412,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default; #else bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( imageLayout == rhs.imageLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69297,19 +77539,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default; #else bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && - ( imageLayout == rhs.imageLayout ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69482,20 +77736,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + renderArea, + layerCount, + viewMask, + colorAttachmentCount, + pColorAttachments, + pDepthAttachment, + pStencilAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( RenderingInfoKHR const & ) const = default; #else bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69648,20 +77927,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ResolveImageInfo2KHR const & ) const = default; #else bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69757,18 +78050,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, components, srgb ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default; #else bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && - ( srgb == rhs.srgb ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -69978,24 +78283,61 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + magFilter, + minFilter, + mipmapMode, + addressModeU, + addressModeV, + addressModeW, + mipLodBias, + anisotropyEnable, + maxAnisotropy, + compareEnable, + compareOp, + minLod, + maxLod, + borderColor, + unnormalizedCoordinates ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerCreateInfo const & ) const = default; #else bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70099,6 +78441,19 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColor, format ); + } + public: VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; const void * pNext = {}; @@ -70176,17 +78531,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reductionMode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default; #else bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70331,20 +78698,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + ycbcrModel, + ycbcrRange, + components, + xChromaOffset, + yChromaOffset, + chromaFilter, + forceExplicitReconstruction ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70421,18 +78813,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, combinedImageSamplerDescriptorCount ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default; #else bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70512,17 +78913,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conversion ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default; #else bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion ); + return this->reflect() == rhs.reflect(); } bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70618,18 +79031,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, context, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; # else bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && - ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -70708,17 +79134,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreCreateInfo const & ) const = default; #else bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70803,18 +79241,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default; #else bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -70904,18 +79354,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default; # else bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -71010,18 +79472,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default; # else bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( handleType == rhs.handleType ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -71108,18 +79582,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSignalInfo const & ) const = default; #else bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( value == rhs.value ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71220,18 +79706,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default; #else bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && - ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71318,18 +79818,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphoreType, initialValue ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default; #else bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && - ( initialValue == rhs.initialValue ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71474,19 +79986,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SemaphoreWaitInfo const & ) const = default; #else bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) && - ( pValues == rhs.pValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71554,17 +80079,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( data ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default; #else bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( data == rhs.data ); + return this->reflect() == rhs.reflect(); } bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71665,18 +80200,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, codeSize, pCode ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleCreateInfo const & ) const = default; #else bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71761,17 +80309,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, validationCache ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71838,20 +80398,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderResourceUsageAMD const & ) const = default; #else bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) && - ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) && - ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) && - ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71918,20 +80486,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple const &> +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shaderStageMask, + resourceUsage, + numPhysicalVgprs, + numPhysicalSgprs, + numAvailableVgprs, + numAvailableSgprs, + computeWorkGroupSize ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default; #else bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) && - ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) && - ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) && - ( computeWorkGroupSize == rhs.computeWorkGroupSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -71994,18 +80581,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sharedPresentSupportedUsageFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72069,17 +80666,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, imageGranularity, flags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties const & ) const = default; #else bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72136,17 +80745,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageFormatProperties2 const & ) const = default; #else bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72216,19 +80837,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements const & ) const = default; #else bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) && - ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) && - ( imageMipTailStride == rhs.imageMipTailStride ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72288,17 +80922,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default; #else bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72390,18 +81036,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, streamDescriptor ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default; # else bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -72491,17 +81149,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( deviceAddress, stride, size ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default; #else bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size ); + return this->reflect() == rhs.reflect(); } bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72696,20 +81366,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphores, + pWaitDstStageMask, + commandBufferCount, + pCommandBuffers, + signalSemaphoreCount, + pSignalSemaphores ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo const & ) const = default; #else bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72895,23 +81588,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + waitSemaphoreInfoCount, + pWaitSemaphoreInfos, + commandBufferInfoCount, + pCommandBufferInfos, + signalSemaphoreInfoCount, + pSignalSemaphoreInfos ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubmitInfo2KHR const & ) const = default; #else bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -72992,17 +81705,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, contents ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassBeginInfo const & ) const = default; #else bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73101,19 +81826,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default; #else bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) && - ( stencilResolveMode == rhs.stencilResolveMode ) && - ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73183,17 +81920,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassEndInfo const & ) const = default; #else bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73259,18 +82006,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, subpass ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default; #else bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && - ( subpass == rhs.subpass ); + return this->reflect() == rhs.reflect(); } bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73355,24 +82114,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags, + supportedSurfaceCounters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2EXT const & ) const = default; #else bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73460,22 +82246,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73538,17 +82347,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCapabilities ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilities2KHR const & ) const = default; #else bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73631,18 +82452,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusiveSupported ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default; # else bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -73706,17 +82536,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( format, colorSpace ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormatKHR const & ) const = default; #else bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73769,17 +82609,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceFormat ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFormat2KHR const & ) const = default; #else bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -73859,17 +82710,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusive ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -73953,17 +82816,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hmonitor ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default; # else bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -74044,17 +82917,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsProtected ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default; #else bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected ); + return this->reflect() == rhs.reflect(); } bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74133,17 +83016,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCounters ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default; #else bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74404,24 +83299,61 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + surface, + minImageCount, + imageFormat, + imageColorSpace, + imageExtent, + imageArrayLayers, + imageUsage, + imageSharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + preTransform, + compositeAlpha, + presentMode, + clipped, + oldSwapchain ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainCreateInfoKHR const & ) const = default; #else bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74518,17 +83450,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingEnable ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default; #else bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable ); + return this->reflect() == rhs.reflect(); } bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74595,18 +83537,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default; #else bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); + return this->reflect() == rhs.reflect(); } bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74742,21 +83693,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreValueCount, + pWaitSemaphoreValues, + signalSemaphoreValueCount, + pSignalSemaphoreValues ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default; #else bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && - ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); + return this->reflect() == rhs.reflect(); } bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74847,17 +83814,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default; #else bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); + return this->reflect() == rhs.reflect(); } bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -74965,18 +83942,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default; #else bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75117,21 +84107,37 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + enabledValidationFeatureCount, + pEnabledValidationFeatures, + disabledValidationFeatureCount, + pDisabledValidationFeatures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFeaturesEXT const & ) const = default; #else bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) && - ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) && - ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) && - ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75238,19 +84244,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ValidationFlagsEXT const & ) const = default; #else bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) && - ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); + return this->reflect() == rhs.reflect(); } bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75354,18 +84371,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, location, binding, format, offset ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default; #else bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && - ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75472,18 +84503,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, binding, stride, inputRate, divisor ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default; #else bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && - ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor ); + return this->reflect() == rhs.reflect(); } bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -75571,17 +84616,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default; # else bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); + return this->reflect() == rhs.reflect(); } bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -75685,19 +84743,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoPictureResourceKHR const & ) const = default; # else bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && - ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) && - ( imageViewBinding == rhs.imageViewBinding ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -75786,18 +84857,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pPictureResource ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoReferenceSlotKHR const & ) const = default; # else bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pPictureResource == rhs.pPictureResource ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -75948,20 +85031,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + codecQualityPreset, + videoSession, + videoSessionParameters, + referenceSlotCount, + pReferenceSlots ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default; # else bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76069,18 +85173,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoBindMemoryKHR const & ) const = default; # else bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && - ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76158,23 +85276,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + capabilityFlags, + minBitstreamBufferOffsetAlignment, + minBitstreamBufferSizeAlignment, + videoPictureExtentGranularity, + minExtent, + maxExtent, + maxReferencePicturesSlotsCount, + maxReferencePicturesActiveCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCapabilitiesKHR const & ) const = default; # else bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76259,17 +85399,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoCodingControlInfoKHR const & ) const = default; # else bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76338,19 +85490,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && - ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) && - ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76433,17 +85597,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76521,17 +85697,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdMvc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default; # else bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76646,18 +85832,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76748,19 +85947,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc, pictureLayout ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && - ( pictureLayout == rhs.pictureLayout ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -76852,18 +86062,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77010,18 +86232,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77130,18 +86366,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77211,18 +86460,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel, stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) && - ( stdExtensionVersion == rhs.stdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77304,17 +86565,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77431,18 +86704,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77523,18 +86809,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77625,18 +86920,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77783,18 +87090,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -77903,18 +87224,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78113,22 +87447,49 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + codedOffset, + codedExtent, + srcBuffer, + srcBufferOffset, + srcBufferRange, + dstPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoDecodeInfoKHR const & ) const = default; # else bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78306,23 +87667,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + inputModeFlags, + outputModeFlags, + minPictureSizeInMbs, + maxPictureSizeInMbs, + inputImageDataAlignment, + maxNumL0ReferenceForP, + maxNumL0ReferenceForB, + maxNumL1Reference, + qualityLevelCount, + stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78421,18 +87810,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pStdPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pStdPictureInfo == rhs.pStdPictureInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78566,19 +87967,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) && - ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && - ( ppsIdEntries == rhs.ppsIdEntries ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78667,17 +88081,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78834,21 +88258,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pSliceHeaderStd, + mbCount, + refFinalList0EntryCount, + pRefFinalList0Entries, + refFinalList1EntryCount, + pRefFinalList1Entries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -78932,18 +88376,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79025,17 +88478,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264QpEXT const & ) const = default; # else bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79136,19 +88599,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && - ( rateControlStructure == rhs.rateControlStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79308,21 +88784,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + temporalLayerId, + useInitialRcQp, + initialRcQp, + useMinQp, + minQp, + useMaxQp, + maxQp, + useMaxFrameSize, + maxFrameSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79432,18 +88934,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79591,18 +89106,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) && - ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79711,18 +89240,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) && - ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -79912,23 +89454,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + refDefaultFinalList0EntryCount, + pRefDefaultFinalList0Entries, + refDefaultFinalList1EntryCount, + pRefDefaultFinalList1Entries, + naluSliceEntryCount, + pNaluSliceEntries, + pCurrentPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80105,23 +89667,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + inputModeFlags, + outputModeFlags, + ctbSizes, + inputImageDataAlignment, + maxNumL0ReferenceForP, + maxNumL0ReferenceForB, + maxNumL1Reference, + maxNumSubLayers, + qualityLevelCount, + stdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default; # else bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80219,18 +89809,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pStdReferenceInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && - ( pStdReferenceInfo == rhs.pStdReferenceInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80385,19 +89987,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default; # else bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80488,17 +90105,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default; # else bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80646,22 +90273,39 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + referenceList0EntryCount, + pReferenceList0Entries, + referenceList1EntryCount, + pReferenceList1Entries, + pReferenceModifications ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default; # else bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( referenceList0EntryCount == rhs.referenceList0EntryCount ) && - ( pReferenceList0Entries == rhs.pReferenceList0Entries ) && - ( referenceList1EntryCount == rhs.referenceList1EntryCount ) && - ( pReferenceList1Entries == rhs.pReferenceList1Entries ) && - ( pReferenceModifications == rhs.pReferenceModifications ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80762,18 +90406,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default; # else bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) && - ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80854,18 +90511,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default; # else bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -80947,17 +90613,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265QpEXT const & ) const = default; # else bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81058,19 +90734,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && - ( rateControlStructure == rhs.rateControlStructure ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81230,21 +90919,47 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + temporalId, + useInitialRcQp, + initialRcQp, + useMinQp, + minQp, + useMaxQp, + maxQp, + useMaxFrameSize, + maxFrameSize ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81345,18 +91060,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pStdExtensionVersion ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( pStdExtensionVersion == rhs.pStdExtensionVersion ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81535,19 +91262,34 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81667,19 +91409,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) && - ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) && - ( pParametersAddInfo == rhs.pParametersAddInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -81815,19 +91570,33 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default; # else bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && - ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && - ( pCurrentPictureInfo == rhs.pCurrentPictureInfo ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82036,24 +91805,51 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + qualityLevel, + codedExtent, + dstBitstreamBuffer, + dstBitstreamBufferOffset, + dstBitstreamBufferMaxRange, + srcPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots, + precedingExternallyEncodedBytes ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeInfoKHR const & ) const = default; # else bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82189,21 +91985,41 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + averageBitrate, + maxBitrate, + frameRateNumerator, + frameRateDenominator, + virtualBufferSizeInMs, + initialVirtualBufferSizeInMs ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82340,19 +92156,32 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; # else bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) && - ( pLayerConfigs == rhs.pLayerConfigs ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82435,17 +92264,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoEndCodingInfoKHR const & ) const = default; # else bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82507,17 +92348,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoFormatPropertiesKHR const & ) const = default; # else bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82605,18 +92456,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default; # else bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && - ( pMemoryRequirements == rhs.pMemoryRequirements ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82698,17 +92561,29 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperations ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default; # else bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82851,22 +92726,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + queueFamilyIndex, + flags, + pVideoProfile, + pictureFormat, + maxCodedExtent, + referencePicturesFormat, + maxReferencePicturesSlotsCount, + maxReferencePicturesActiveCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -82964,19 +92862,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) && - ( videoSession == rhs.videoSession ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -83059,17 +92968,27 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, updateSequenceCount ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default; # else bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount ); + return this->reflect() == rhs.reflect(); } bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -83164,18 +93083,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, display, surface ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && - ( surface == rhs.surface ); + return this->reflect() == rhs.reflect(); } bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -83420,20 +93352,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + acquireCount, + pAcquireSyncs, + pAcquireKeys, + pAcquireTimeouts, + releaseCount, + pReleaseSyncs, + pReleaseKeys ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -83683,21 +93638,43 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + acquireCount, + pAcquireSyncs, + pAcquireKeys, + pAcquireTimeoutMilliseconds, + releaseCount, + pReleaseSyncs, + pReleaseKeys ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default; # else bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -83798,18 +93775,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, hinstance, hwnd ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default; # else bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd ); + return this->reflect() == rhs.reflect(); } bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -84016,21 +94006,45 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + dstSet, + dstBinding, + dstArrayElement, + descriptorCount, + descriptorType, + pImageInfo, + pBufferInfo, + pTexelBufferView ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSet const & ) const = default; #else bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - 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 ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84148,19 +94162,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84275,19 +94300,30 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std::tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default; #else bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84398,17 +94434,28 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +#if 14 <= VULKAN_HPP_CPP_VERSION + auto +#else + std:: + tuple +#endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } + #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default; #else bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + return this->reflect() == rhs.reflect(); } bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } #endif @@ -84504,18 +94551,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, connection, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif @@ -84610,18 +94670,31 @@ namespace VULKAN_HPP_NAMESPACE return *reinterpret_cast( this ); } +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dpy, window ); + } + # if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default; # else bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) && - ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 ); + return this->reflect() == rhs.reflect(); } bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT { - return !operator==( rhs ); + return this->reflect() != rhs.reflect(); } # endif