From abce7c90cd524ab91ee7fe83974cac7e15d0c179 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Mon, 13 Jul 2020 11:45:47 +0200 Subject: [PATCH] Remove (most of) the special handling of structure members named "sType", replace it by handling of structure members with a "values" attribute with a single element. --- VulkanHppGenerator.cpp | 190 ++- VulkanHppGenerator.hpp | 9 +- vulkan/vulkan.hpp | 3595 ++++++++++++++++++++++++++-------------- 3 files changed, 2499 insertions(+), 1295 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 4884768..1fb8575 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -83,6 +83,7 @@ std::string stripPostfix( std::string const & value, std::string const & postfix std::string stripPluralS( std::string const & name ); std::string stripPrefix( std::string const & value, std::string const & prefix ); std::string toCamelCase( std::string const & value ); +std::string toString( std::vector const & strings ); std::string toUpperCase( std::string const & name ); std::vector tokenize( std::string const & tokenString, std::string const & separator ); std::string trim( std::string const & input ); @@ -95,8 +96,6 @@ const std::set ignoreLens = { "null-terminated", "2*VK_UUID_SIZE", "2*ename:VK_UUID_SIZE" }; -const std::set nonConstSTypeStructs = { "VkBaseInStructure", "VkBaseOutStructure" }; - void appendArgumentCount( std::string & str, size_t vectorIndex, std::string const & vectorName, @@ -700,6 +699,20 @@ std::string toCamelCase( std::string const & value ) return result; } +std::string toString( std::vector const & strings ) +{ + std::string str; + if ( !strings.empty() ) + { + str = strings[0]; + for ( size_t i = 1; i < strings.size(); i++ ) + { + str += ", " + strings[i]; + } + } + return str; +} + std::string toUpperCase( std::string const & name ) { std::string convertedName; @@ -3507,22 +3520,31 @@ ${prefix}} str += replaceWithMap( assignmentFromVulkanType, { { "prefix", prefix }, { "structName", stripPrefix( structData.first, "Vk" ) } } ); - // we need an assignment operator if there is constant sType in this struct - std::string copyTemplate; - if ( ( nonConstSTypeStructs.find( structData.first ) == nonConstSTypeStructs.end() ) && - !structData.second.members.empty() && ( structData.second.members.front().name == "sType" ) ) + // we need an assignment operator if there is constant member in this struct + if ( std::find_if( structData.second.members.begin(), structData.second.members.end(), []( MemberData const & md ) { + return md.values.size() == 1; + } ) != structData.second.members.end() ) { - assert( ( 2 <= structData.second.members.size() ) && ( structData.second.members[1].name == "pNext" ) ); + std::string assignments; + for ( auto member : structData.second.members ) + { + if ( member.values.size() != 1 ) + { + assignments += prefix + member.name + " = rhs." + member.name + ";\n"; + } + } - static const std::string stringTemplate = R"( + static const std::string assignmentTemplate = R"( ${prefix}${structName} & operator=( ${structName} const & rhs ) VULKAN_HPP_NOEXCEPT ${prefix}{ -${prefix} memcpy( &pNext, &rhs.pNext, sizeof( ${structName} ) - offsetof( ${structName}, pNext ) ); +${assignments} ${prefix} return *this; ${prefix}} )"; - str += replaceWithMap( stringTemplate, - { { "prefix", prefix }, { "structName", stripPrefix( structData.first, "Vk" ) } } ); + str += replaceWithMap( assignmentTemplate, + { { "assignments", assignments }, + { "prefix", prefix }, + { "structName", stripPrefix( structData.first, "Vk" ) } } ); } } @@ -3627,8 +3649,8 @@ ${prefix}} // gather the arguments listedArgument = appendStructConstructorArgument( arguments, listedArgument, member, true ); - // gather the initializers; skip members 'pNext' and 'sType', they are directly set by initializers - if ( ( member.name != "pNext" ) && ( member.name != "sType" ) ) + // gather the initializers; skip member 'pNext' and constant members + if ( ( member.name != "pNext" ) && ( member.values.size() != 1 ) ) { initializers += ( firstArgument ? ":" : "," ) + std::string( " " ) + member.name + "( " + member.name + "_ )"; firstArgument = false; @@ -3678,8 +3700,8 @@ void VulkanHppGenerator::appendStructConstructorsEnhanced( std::string & std::string templateHeader, sizeChecks; for ( auto mit = structData.second.members.begin(); mit != structData.second.members.end(); ++mit ) { - // gather the initializers; skip members 'pNext' and 'sType', they are directly set by initializers - if ( ( mit->name != "pNext" ) && ( mit->name != "sType" ) ) + // gather the initializers; skip member 'pNext' and constant members + if ( ( mit->name != "pNext" ) && ( mit->values.size() != 1 ) ) { auto litit = lenIts.find( mit ); if ( litit != lenIts.end() ) @@ -3748,8 +3770,8 @@ bool VulkanHppGenerator::appendStructConstructorArgument( std::string & str MemberData const & memberData, bool withDefault ) const { - // skip members 'pNext' and 'sType', as they are never explicitly set - if ( ( memberData.name != "pNext" ) && ( memberData.name != "sType" ) ) + // skip members 'pNext' and members with a single value, as they are never explicitly set + if ( ( memberData.name != "pNext" ) && ( memberData.values.size() != 1 ) ) { str += ( listedArgument ? ( ", " ) : "" ); if ( memberData.arraySizes.empty() ) @@ -3772,7 +3794,9 @@ bool VulkanHppGenerator::appendStructConstructorArgument( std::string & str } else if ( !memberData.values.empty() ) { - str += memberData.values; + // member with multiple values (those with just one don't get here) arbitrarily get the first value as their + // default + str += memberData.values.front(); } else { @@ -3794,11 +3818,9 @@ std::string VulkanHppGenerator::appendStructMembers( std::string & for ( auto const & member : structData.second.members ) { str += prefix; - if ( ( member.name == "sType" ) && - ( nonConstSTypeStructs.find( structData.first ) == - nonConstSTypeStructs - .end() ) ) // special handling for sType and some nasty little structs that don't get a const sType + if ( member.values.size() == 1 ) { + // members with just one allowed value are set to be const str += "const "; } if ( !member.bitCount.empty() && beginsWith( member.type.type, "Vk" ) ) @@ -3816,25 +3838,23 @@ std::string VulkanHppGenerator::appendStructMembers( std::string & str += constructStandardArrayWrapper( member.type.compose(), member.arraySizes ); } str += " " + member.name; - if ( member.name == "sType" ) // special handling for sType + if ( !member.values.empty() ) { - auto enumIt = m_enums.find( "VkStructureType" ); + // special handling for members with legal value: arbitrarily use the first one as the default + auto enumIt = m_enums.find( member.type.type ); assert( enumIt != m_enums.end() ); - if ( !member.values.empty() ) { - assert( beginsWith( member.values, "VK_STRUCTURE_TYPE" ) ); - auto nameIt = + std::string enumValue = member.values.front(); + auto nameIt = std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), - [&member]( EnumValueData const & evd ) { return member.values == evd.vulkanValue; } ); + [&enumValue]( EnumValueData const & evd ) { return enumValue == evd.vulkanValue; } ); assert( nameIt != enumIt->second.values.end() ); - sTypeValue = nameIt->vkValue; - str += " = StructureType::" + sTypeValue; - } - else - { - // special handling for those nasty structs with an unspecified value for sType - str += " = {}"; + str += " = " + stripPrefix( member.type.type, "Vk" ) + "::" + nameIt->vkValue; + if ( member.name == "sType" ) + { + sTypeValue = nameIt->vkValue; + } } } else @@ -3854,10 +3874,6 @@ std::string VulkanHppGenerator::appendStructMembers( std::string & { appendEnumInitializer( str, member.type, member.arraySizes, enumIt->second.values ); } - else if ( !member.values.empty() ) - { - str += member.values; - } else { str += "{}"; @@ -4404,7 +4420,7 @@ void VulkanHppGenerator::EnumData::addEnumValue( int line, } ); if ( it == values.end() ) { - values.push_back( EnumValueData( valueName, translatedName, bitpos ) ); + values.push_back( EnumValueData( line, valueName, translatedName, bitpos ) ); } else { @@ -4472,8 +4488,7 @@ void VulkanHppGenerator::checkCorrectness() } } - auto structureTypeIt = m_enums.find( "VkStructureType" ); - assert( structureTypeIt != m_enums.end() ); + std::set sTypeValues; for ( auto const & structure : m_structures ) { for ( auto const & extend : structure.second.structExtends ) @@ -4516,18 +4531,73 @@ void VulkanHppGenerator::checkCorrectness() member.xmlLine, "struct member array size uses unknown constant <" + member.usedConstant + ">" ); } - if ( !member.values.empty() && ( member.name == "sType" ) ) + if ( !member.values.empty() ) { - check( std::find_if( structureTypeIt->second.values.begin(), - structureTypeIt->second.values.end(), - [&member]( auto const & evd ) { return member.values == evd.vulkanValue; } ) != - structureTypeIt->second.values.end(), - member.xmlLine, - "sType value <" + member.values + "> not listed for VkStructureType" ); + auto enumIt = m_enums.find( member.type.type ); + if ( enumIt != m_enums.end() ) + { + for ( auto const & enumValue : member.values ) + { + check( std::find_if( enumIt->second.values.begin(), + enumIt->second.values.end(), + [&enumValue]( auto const & evd ) { return enumValue == evd.vulkanValue; } ) != + enumIt->second.values.end(), + member.xmlLine, + "value <" + enumValue + "> for structure member <" + member.name + "> of enum type <" + + member.type.type + "> not listed" ); + } + // special handling for sType: no value should appear more than once + if ( member.name == "sType" ) + { + for ( auto const & enumValue : member.values ) + { + check( sTypeValues.insert( enumValue ).second, + member.xmlLine, + "sType value <" + enumValue + "> has been used before" ); + } + } + } + else if ( member.type.type == "uint32_t" ) + { + for ( auto const & value : member.values ) + { + check( value.find_first_not_of( "0123456789" ) == std::string::npos, + member.xmlLine, + "value <" + value + "> for struct member <" + member.name + "> of type <" + member.type.type + + "> in structure <" + structure.first + "> is not a number" ); + } + } + else + { + check( false, + member.xmlLine, + "member <" + member.name + "> in structure <" + structure.first + "> holds values <" + + ::toString( member.values ) + "> for an unhandled type <" + member.type.type + ">" ); + } } } } + auto structureTypeIt = m_enums.find( "VkStructureType" ); + assert( structureTypeIt != m_enums.end() ); + for ( auto const & enumValue : structureTypeIt->second.values ) + { + if ( ( enumValue.vulkanValue == "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO" ) || + ( enumValue.vulkanValue == "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO" ) ) + { + check( sTypeValues.find( enumValue.vulkanValue ) == sTypeValues.end(), + enumValue.xmlLine, + "Reserved VkStructureType enum value <" + enumValue.vulkanValue + "> is used" ); + } + else + { + warn( sTypeValues.erase( enumValue.vulkanValue ) == 1, + enumValue.xmlLine, + "VkStructureType enum value <" + enumValue.vulkanValue + "> never used" ); + } + } + assert( sTypeValues.empty() ); + auto resultIt = m_enums.find( "VkResult" ); assert( resultIt != m_enums.end() ); std::set resultCodes; @@ -5048,17 +5118,6 @@ std::set VulkanHppGenerator::getPlatforms( std::set co return platforms; } -bool VulkanHppGenerator::holdsSType( std::string const & type ) const -{ - auto it = m_structures.find( type ); - if ( it != m_structures.end() ) - { - assert( !it->second.members.empty() ); - return ( it->second.members.front().name == "sType" ); - } - return false; -} - bool VulkanHppGenerator::isParam( std::string const & name, std::vector const & params ) const { return std::find_if( params.begin(), params.end(), [&name]( ParamData const & pd ) { return pd.name == name; } ) != @@ -6787,16 +6846,7 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, } else if ( attribute.first == "values" ) { - check( tokenize( attribute.second, "," ).size() == 1, - line, - "struct member <" + memberData.name + "> holds mulitple values <" + attribute.second + ">" ); - if ( memberData.name == "sType" ) - { - check( m_sTypeValues.insert( attribute.second ).second, - line, - "<" + attribute.second + "> already encountered as values for the sType member of a struct" ); - } - memberData.values = attribute.second; + memberData.values = tokenize( attribute.second, "," ); } } diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index befc9f6..99400c0 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -116,13 +116,14 @@ private: struct EnumValueData { - EnumValueData( std::string const & vulkan, std::string const & vk, bool singleBit_ ) - : vulkanValue( vulkan ), vkValue( vk ), singleBit( singleBit_ ) + EnumValueData( int line, std::string const & vulkan, std::string const & vk, bool singleBit_ ) + : vulkanValue( vulkan ), vkValue( vk ), singleBit( singleBit_ ), xmlLine(line) {} std::string vulkanValue; std::string vkValue; bool singleBit; + int xmlLine; }; struct EnumData @@ -198,7 +199,7 @@ private: bool optional = false; std::string selection; std::string selector; - std::string values; + std::vector values; std::string usedConstant; int xmlLine; }; @@ -528,7 +529,6 @@ private: std::string const & structName, std::string const & prefix ) const; std::set getPlatforms( std::set const & extensions ) const; - bool holdsSType( std::string const & type ) const; bool isParam( std::string const & name, std::vector const & params ) const; bool isParamIndirect( std::string const & name, std::vector const & params ) const; bool isTwoStepAlgorithm( std::vector const & params ) const; @@ -628,7 +628,6 @@ private: std::map m_platforms; std::map m_structureAliases; std::map m_structures; - std::set m_sTypeValues; std::set m_tags; std::map m_types; std::string m_typesafeCheck; diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index ca523d2..ad8f2bc 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -27125,10 +27125,14 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureGeometryTrianglesDataKHR ) - - offsetof( AccelerationStructureGeometryTrianglesDataKHR, pNext ) ); + pNext = rhs.pNext; + vertexFormat = rhs.vertexFormat; + vertexData = rhs.vertexData; + vertexStride = rhs.vertexStride; + indexType = rhs.indexType; + indexData = rhs.indexData; + transformData = rhs.transformData; + return *this; } @@ -27244,10 +27248,10 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureGeometryAabbsDataKHR ) - - offsetof( AccelerationStructureGeometryAabbsDataKHR, pNext ) ); + pNext = rhs.pNext; + data = rhs.data; + stride = rhs.stride; + return *this; } @@ -27332,10 +27336,10 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureGeometryInstancesDataKHR ) - - offsetof( AccelerationStructureGeometryInstancesDataKHR, pNext ) ); + pNext = rhs.pNext; + arrayOfPointers = rhs.arrayOfPointers; + data = rhs.data; + return *this; } @@ -27491,9 +27495,11 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureGeometryKHR ) - offsetof( AccelerationStructureGeometryKHR, pNext ) ); + pNext = rhs.pNext; + geometryType = rhs.geometryType; + geometry = rhs.geometry; + flags = rhs.flags; + return *this; } @@ -27651,10 +27657,17 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureBuildGeometryInfoKHR ) - - offsetof( AccelerationStructureBuildGeometryInfoKHR, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + flags = rhs.flags; + update = rhs.update; + srcAccelerationStructure = rhs.srcAccelerationStructure; + dstAccelerationStructure = rhs.dstAccelerationStructure; + geometryArrayOfPointers = rhs.geometryArrayOfPointers; + geometryCount = rhs.geometryCount; + ppGeometries = rhs.ppGeometries; + scratchData = rhs.scratchData; + return *this; } @@ -27891,10 +27904,14 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureCreateGeometryTypeInfoKHR & operator=( AccelerationStructureCreateGeometryTypeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureCreateGeometryTypeInfoKHR ) - - offsetof( AccelerationStructureCreateGeometryTypeInfoKHR, pNext ) ); + pNext = rhs.pNext; + geometryType = rhs.geometryType; + maxPrimitiveCount = rhs.maxPrimitiveCount; + indexType = rhs.indexType; + maxVertexCount = rhs.maxVertexCount; + vertexFormat = rhs.vertexFormat; + allowsTransforms = rhs.allowsTransforms; + return *this; } @@ -28051,9 +28068,14 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureCreateInfoKHR ) - offsetof( AccelerationStructureCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + compactedSize = rhs.compactedSize; + type = rhs.type; + flags = rhs.flags; + maxGeometryCount = rhs.maxGeometryCount; + pGeometryInfos = rhs.pGeometryInfos; + deviceAddress = rhs.deviceAddress; + return *this; } @@ -28210,7 +28232,19 @@ namespace VULKAN_HPP_NAMESPACE GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( GeometryTrianglesNV ) - offsetof( GeometryTrianglesNV, pNext ) ); + 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; } @@ -28370,7 +28404,12 @@ namespace VULKAN_HPP_NAMESPACE GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( GeometryAABBNV ) - offsetof( GeometryAABBNV, pNext ) ); + pNext = rhs.pNext; + aabbData = rhs.aabbData; + numAABBs = rhs.numAABBs; + stride = rhs.stride; + offset = rhs.offset; + return *this; } @@ -28539,7 +28578,11 @@ namespace VULKAN_HPP_NAMESPACE GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( GeometryNV ) - offsetof( GeometryNV, pNext ) ); + pNext = rhs.pNext; + geometryType = rhs.geometryType; + geometry = rhs.geometry; + flags = rhs.flags; + return *this; } @@ -28655,8 +28698,13 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( AccelerationStructureInfoNV ) - offsetof( AccelerationStructureInfoNV, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + flags = rhs.flags; + instanceCount = rhs.instanceCount; + geometryCount = rhs.geometryCount; + pGeometries = rhs.pGeometries; + return *this; } @@ -28783,9 +28831,10 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureCreateInfoNV ) - offsetof( AccelerationStructureCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + compactedSize = rhs.compactedSize; + info = rhs.info; + return *this; } @@ -28881,10 +28930,9 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureDeviceAddressInfoKHR ) - - offsetof( AccelerationStructureDeviceAddressInfoKHR, pNext ) ); + pNext = rhs.pNext; + accelerationStructure = rhs.accelerationStructure; + return *this; } @@ -29146,10 +29194,11 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureMemoryRequirementsInfoKHR & operator=( AccelerationStructureMemoryRequirementsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureMemoryRequirementsInfoKHR ) - - offsetof( AccelerationStructureMemoryRequirementsInfoKHR, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + buildType = rhs.buildType; + accelerationStructure = rhs.accelerationStructure; + return *this; } @@ -29258,10 +29307,10 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureMemoryRequirementsInfoNV ) - - offsetof( AccelerationStructureMemoryRequirementsInfoNV, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + accelerationStructure = rhs.accelerationStructure; + return *this; } @@ -29353,9 +29402,9 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureVersionKHR & operator=( AccelerationStructureVersionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AccelerationStructureVersionKHR ) - offsetof( AccelerationStructureVersionKHR, pNext ) ); + pNext = rhs.pNext; + versionData = rhs.versionData; + return *this; } @@ -29444,7 +29493,13 @@ namespace VULKAN_HPP_NAMESPACE AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( AcquireNextImageInfoKHR ) - offsetof( AcquireNextImageInfoKHR, pNext ) ); + pNext = rhs.pNext; + swapchain = rhs.swapchain; + timeout = rhs.timeout; + semaphore = rhs.semaphore; + fence = rhs.fence; + deviceMask = rhs.deviceMask; + return *this; } @@ -29555,8 +29610,10 @@ namespace VULKAN_HPP_NAMESPACE AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( AcquireProfilingLockInfoKHR ) - offsetof( AcquireProfilingLockInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + timeout = rhs.timeout; + return *this; } @@ -29855,10 +29912,16 @@ namespace VULKAN_HPP_NAMESPACE AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AndroidHardwareBufferFormatPropertiesANDROID ) - - offsetof( AndroidHardwareBufferFormatPropertiesANDROID, pNext ) ); + 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; } @@ -29947,10 +30010,10 @@ namespace VULKAN_HPP_NAMESPACE AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AndroidHardwareBufferPropertiesANDROID ) - - offsetof( AndroidHardwareBufferPropertiesANDROID, pNext ) ); + pNext = rhs.pNext; + allocationSize = rhs.allocationSize; + memoryTypeBits = rhs.memoryTypeBits; + return *this; } @@ -30024,9 +30087,9 @@ namespace VULKAN_HPP_NAMESPACE AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AndroidHardwareBufferUsageANDROID ) - offsetof( AndroidHardwareBufferUsageANDROID, pNext ) ); + pNext = rhs.pNext; + androidHardwareBufferUsage = rhs.androidHardwareBufferUsage; + return *this; } @@ -30099,8 +30162,10 @@ namespace VULKAN_HPP_NAMESPACE AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( AndroidSurfaceCreateInfoKHR ) - offsetof( AndroidSurfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + window = rhs.window; + return *this; } @@ -30197,7 +30262,13 @@ namespace VULKAN_HPP_NAMESPACE ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ApplicationInfo ) - offsetof( ApplicationInfo, pNext ) ); + pNext = rhs.pNext; + pApplicationName = rhs.pApplicationName; + applicationVersion = rhs.applicationVersion; + pEngineName = rhs.pEngineName; + engineVersion = rhs.engineVersion; + apiVersion = rhs.apiVersion; + return *this; } @@ -30458,7 +30529,17 @@ namespace VULKAN_HPP_NAMESPACE AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( AttachmentDescription2 ) - offsetof( AttachmentDescription2, pNext ) ); + 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; } @@ -30604,9 +30685,10 @@ namespace VULKAN_HPP_NAMESPACE AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AttachmentDescriptionStencilLayout ) - offsetof( AttachmentDescriptionStencilLayout, pNext ) ); + pNext = rhs.pNext; + stencilInitialLayout = rhs.stencilInitialLayout; + stencilFinalLayout = rhs.stencilFinalLayout; + return *this; } @@ -30767,7 +30849,11 @@ namespace VULKAN_HPP_NAMESPACE AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( AttachmentReference2 ) - offsetof( AttachmentReference2, pNext ) ); + pNext = rhs.pNext; + attachment = rhs.attachment; + layout = rhs.layout; + aspectMask = rhs.aspectMask; + return *this; } @@ -30863,9 +30949,9 @@ namespace VULKAN_HPP_NAMESPACE AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( AttachmentReferenceStencilLayout ) - offsetof( AttachmentReferenceStencilLayout, pNext ) ); + pNext = rhs.pNext; + stencilLayout = rhs.stencilLayout; + return *this; } @@ -31094,7 +31180,12 @@ namespace VULKAN_HPP_NAMESPACE SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SampleLocationsInfoEXT ) - offsetof( SampleLocationsInfoEXT, pNext ) ); + pNext = rhs.pNext; + sampleLocationsPerPixel = rhs.sampleLocationsPerPixel; + sampleLocationGridSize = rhs.sampleLocationGridSize; + sampleLocationsCount = rhs.sampleLocationsCount; + pSampleLocations = rhs.pSampleLocations; + return *this; } @@ -31258,7 +31349,9 @@ namespace VULKAN_HPP_NAMESPACE struct BaseInStructure { #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - BaseInStructure() VULKAN_HPP_NOEXCEPT {} + BaseInStructure( VULKAN_HPP_NAMESPACE::StructureType sType_ = + VULKAN_HPP_NAMESPACE::StructureType::eApplicationInfo ) VULKAN_HPP_NOEXCEPT : sType( sType_ ) + {} BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT { @@ -31303,7 +31396,7 @@ namespace VULKAN_HPP_NAMESPACE #endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = VULKAN_HPP_NAMESPACE::StructureType::eApplicationInfo; const struct VULKAN_HPP_NAMESPACE::BaseInStructure * pNext = {}; }; static_assert( sizeof( BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); @@ -31312,7 +31405,9 @@ namespace VULKAN_HPP_NAMESPACE struct BaseOutStructure { #if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - BaseOutStructure() VULKAN_HPP_NOEXCEPT {} + BaseOutStructure( VULKAN_HPP_NAMESPACE::StructureType sType_ = + VULKAN_HPP_NAMESPACE::StructureType::eApplicationInfo ) VULKAN_HPP_NOEXCEPT : sType( sType_ ) + {} BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT { @@ -31357,7 +31452,7 @@ namespace VULKAN_HPP_NAMESPACE #endif public: - VULKAN_HPP_NAMESPACE::StructureType sType = {}; + VULKAN_HPP_NAMESPACE::StructureType sType = VULKAN_HPP_NAMESPACE::StructureType::eApplicationInfo; struct VULKAN_HPP_NAMESPACE::BaseOutStructure * pNext = {}; }; static_assert( sizeof( BaseOutStructure ) == sizeof( VkBaseOutStructure ), @@ -31414,10 +31509,13 @@ namespace VULKAN_HPP_NAMESPACE BindAccelerationStructureMemoryInfoKHR & operator=( BindAccelerationStructureMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BindAccelerationStructureMemoryInfoKHR ) - - offsetof( BindAccelerationStructureMemoryInfoKHR, pNext ) ); + pNext = rhs.pNext; + accelerationStructure = rhs.accelerationStructure; + memory = rhs.memory; + memoryOffset = rhs.memoryOffset; + deviceIndexCount = rhs.deviceIndexCount; + pDeviceIndices = rhs.pDeviceIndices; + return *this; } @@ -31549,9 +31647,10 @@ namespace VULKAN_HPP_NAMESPACE BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BindBufferMemoryDeviceGroupInfo ) - offsetof( BindBufferMemoryDeviceGroupInfo, pNext ) ); + pNext = rhs.pNext; + deviceIndexCount = rhs.deviceIndexCount; + pDeviceIndices = rhs.pDeviceIndices; + return *this; } @@ -31653,7 +31752,11 @@ namespace VULKAN_HPP_NAMESPACE BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BindBufferMemoryInfo ) - offsetof( BindBufferMemoryInfo, pNext ) ); + pNext = rhs.pNext; + buffer = rhs.buffer; + memory = rhs.memory; + memoryOffset = rhs.memoryOffset; + return *this; } @@ -31893,9 +31996,12 @@ namespace VULKAN_HPP_NAMESPACE BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BindImageMemoryDeviceGroupInfo ) - offsetof( BindImageMemoryDeviceGroupInfo, pNext ) ); + pNext = rhs.pNext; + deviceIndexCount = rhs.deviceIndexCount; + pDeviceIndices = rhs.pDeviceIndices; + splitInstanceBindRegionCount = rhs.splitInstanceBindRegionCount; + pSplitInstanceBindRegions = rhs.pSplitInstanceBindRegions; + return *this; } @@ -32026,7 +32132,11 @@ namespace VULKAN_HPP_NAMESPACE BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BindImageMemoryInfo ) - offsetof( BindImageMemoryInfo, pNext ) ); + pNext = rhs.pNext; + image = rhs.image; + memory = rhs.memory; + memoryOffset = rhs.memoryOffset; + return *this; } @@ -32122,9 +32232,10 @@ namespace VULKAN_HPP_NAMESPACE BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BindImageMemorySwapchainInfoKHR ) - offsetof( BindImageMemorySwapchainInfoKHR, pNext ) ); + pNext = rhs.pNext; + swapchain = rhs.swapchain; + imageIndex = rhs.imageIndex; + return *this; } @@ -32214,7 +32325,9 @@ namespace VULKAN_HPP_NAMESPACE BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BindImagePlaneMemoryInfo ) - offsetof( BindImagePlaneMemoryInfo, pNext ) ); + pNext = rhs.pNext; + planeAspect = rhs.planeAspect; + return *this; } @@ -33178,7 +33291,18 @@ namespace VULKAN_HPP_NAMESPACE BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BindSparseInfo ) - offsetof( BindSparseInfo, pNext ) ); + 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; } @@ -33558,7 +33682,14 @@ namespace VULKAN_HPP_NAMESPACE BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BufferCreateInfo ) - offsetof( BufferCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + size = rhs.size; + usage = rhs.usage; + sharingMode = rhs.sharingMode; + queueFamilyIndexCount = rhs.queueFamilyIndexCount; + pQueueFamilyIndices = rhs.pQueueFamilyIndices; + return *this; } @@ -33686,9 +33817,9 @@ namespace VULKAN_HPP_NAMESPACE BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BufferDeviceAddressCreateInfoEXT ) - offsetof( BufferDeviceAddressCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + deviceAddress = rhs.deviceAddress; + return *this; } @@ -33769,7 +33900,9 @@ namespace VULKAN_HPP_NAMESPACE BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BufferDeviceAddressInfo ) - offsetof( BufferDeviceAddressInfo, pNext ) ); + pNext = rhs.pNext; + buffer = rhs.buffer; + return *this; } @@ -34047,7 +34180,15 @@ namespace VULKAN_HPP_NAMESPACE BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BufferMemoryBarrier ) - offsetof( BufferMemoryBarrier, pNext ) ); + 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; } @@ -34171,9 +34312,9 @@ namespace VULKAN_HPP_NAMESPACE BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BufferMemoryRequirementsInfo2 ) - offsetof( BufferMemoryRequirementsInfo2, pNext ) ); + pNext = rhs.pNext; + buffer = rhs.buffer; + return *this; } @@ -34256,10 +34397,9 @@ namespace VULKAN_HPP_NAMESPACE BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( BufferOpaqueCaptureAddressCreateInfo ) - - offsetof( BufferOpaqueCaptureAddressCreateInfo, pNext ) ); + pNext = rhs.pNext; + opaqueCaptureAddress = rhs.opaqueCaptureAddress; + return *this; } @@ -34348,7 +34488,13 @@ namespace VULKAN_HPP_NAMESPACE BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( BufferViewCreateInfo ) - offsetof( BufferViewCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + buffer = rhs.buffer; + format = rhs.format; + offset = rhs.offset; + range = rhs.range; + return *this; } @@ -34458,8 +34604,9 @@ namespace VULKAN_HPP_NAMESPACE CalibratedTimestampInfoEXT & operator=( CalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( CalibratedTimestampInfoEXT ) - offsetof( CalibratedTimestampInfoEXT, pNext ) ); + pNext = rhs.pNext; + timeDomain = rhs.timeDomain; + return *this; } @@ -34542,7 +34689,10 @@ namespace VULKAN_HPP_NAMESPACE CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( CheckpointDataNV ) - offsetof( CheckpointDataNV, pNext ) ); + pNext = rhs.pNext; + stage = rhs.stage; + pCheckpointMarker = rhs.pCheckpointMarker; + return *this; } @@ -35101,7 +35251,11 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferAllocateInfo ) - offsetof( CommandBufferAllocateInfo, pNext ) ); + pNext = rhs.pNext; + commandPool = rhs.commandPool; + level = rhs.level; + commandBufferCount = rhs.commandBufferCount; + return *this; } @@ -35207,8 +35361,14 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( CommandBufferInheritanceInfo ) - offsetof( CommandBufferInheritanceInfo, pNext ) ); + pNext = rhs.pNext; + renderPass = rhs.renderPass; + subpass = rhs.subpass; + framebuffer = rhs.framebuffer; + occlusionQueryEnable = rhs.occlusionQueryEnable; + queryFlags = rhs.queryFlags; + pipelineStatistics = rhs.pipelineStatistics; + return *this; } @@ -35332,7 +35492,10 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( CommandBufferBeginInfo ) - offsetof( CommandBufferBeginInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pInheritanceInfo = rhs.pInheritanceInfo; + return *this; } @@ -35426,10 +35589,9 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CommandBufferInheritanceConditionalRenderingInfoEXT ) - - offsetof( CommandBufferInheritanceConditionalRenderingInfoEXT, pNext ) ); + pNext = rhs.pNext; + conditionalRenderingEnable = rhs.conditionalRenderingEnable; + return *this; } @@ -35522,10 +35684,10 @@ namespace VULKAN_HPP_NAMESPACE CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CommandBufferInheritanceRenderPassTransformInfoQCOM ) - - offsetof( CommandBufferInheritanceRenderPassTransformInfoQCOM, pNext ) ); + pNext = rhs.pNext; + transform = rhs.transform; + renderArea = rhs.renderArea; + return *this; } @@ -35620,7 +35782,10 @@ namespace VULKAN_HPP_NAMESPACE CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( CommandPoolCreateInfo ) - offsetof( CommandPoolCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + queueFamilyIndex = rhs.queueFamilyIndex; + return *this; } @@ -35908,9 +36073,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineShaderStageCreateInfo ) - offsetof( PipelineShaderStageCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + stage = rhs.stage; + module = rhs.module; + pName = rhs.pName; + pSpecializationInfo = rhs.pSpecializationInfo; + return *this; } @@ -36029,7 +36198,13 @@ namespace VULKAN_HPP_NAMESPACE ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ComputePipelineCreateInfo ) - offsetof( ComputePipelineCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + stage = rhs.stage; + layout = rhs.layout; + basePipelineHandle = rhs.basePipelineHandle; + basePipelineIndex = rhs.basePipelineIndex; + return *this; } @@ -36146,9 +36321,11 @@ namespace VULKAN_HPP_NAMESPACE ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ConditionalRenderingBeginInfoEXT ) - offsetof( ConditionalRenderingBeginInfoEXT, pNext ) ); + pNext = rhs.pNext; + buffer = rhs.buffer; + offset = rhs.offset; + flags = rhs.flags; + return *this; } @@ -36342,9 +36519,16 @@ namespace VULKAN_HPP_NAMESPACE CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CooperativeMatrixPropertiesNV ) - offsetof( CooperativeMatrixPropertiesNV, pNext ) ); + 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; } @@ -36482,9 +36666,11 @@ namespace VULKAN_HPP_NAMESPACE CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CopyAccelerationStructureInfoKHR ) - offsetof( CopyAccelerationStructureInfoKHR, pNext ) ); + pNext = rhs.pNext; + src = rhs.src; + dst = rhs.dst; + mode = rhs.mode; + return *this; } @@ -36593,10 +36779,11 @@ namespace VULKAN_HPP_NAMESPACE CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CopyAccelerationStructureToMemoryInfoKHR ) - - offsetof( CopyAccelerationStructureToMemoryInfoKHR, pNext ) ); + pNext = rhs.pNext; + src = rhs.src; + dst = rhs.dst; + mode = rhs.mode; + return *this; } @@ -36694,7 +36881,15 @@ namespace VULKAN_HPP_NAMESPACE CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( CopyDescriptorSet ) - offsetof( CopyDescriptorSet, pNext ) ); + 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; } @@ -36829,10 +37024,11 @@ namespace VULKAN_HPP_NAMESPACE CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( CopyMemoryToAccelerationStructureInfoKHR ) - - offsetof( CopyMemoryToAccelerationStructureInfoKHR, pNext ) ); + pNext = rhs.pNext; + src = rhs.src; + dst = rhs.dst; + mode = rhs.mode; + return *this; } @@ -36936,7 +37132,12 @@ namespace VULKAN_HPP_NAMESPACE D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( D3D12FenceSubmitInfoKHR ) - offsetof( D3D12FenceSubmitInfoKHR, pNext ) ); + pNext = rhs.pNext; + waitSemaphoreValuesCount = rhs.waitSemaphoreValuesCount; + pWaitSemaphoreValues = rhs.pWaitSemaphoreValues; + signalSemaphoreValuesCount = rhs.signalSemaphoreValuesCount; + pSignalSemaphoreValues = rhs.pSignalSemaphoreValues; + return *this; } @@ -37063,7 +37264,10 @@ namespace VULKAN_HPP_NAMESPACE DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DebugMarkerMarkerInfoEXT ) - offsetof( DebugMarkerMarkerInfoEXT, pNext ) ); + pNext = rhs.pNext; + pMarkerName = rhs.pMarkerName; + color = rhs.color; + return *this; } @@ -37155,8 +37359,11 @@ namespace VULKAN_HPP_NAMESPACE DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DebugMarkerObjectNameInfoEXT ) - offsetof( DebugMarkerObjectNameInfoEXT, pNext ) ); + pNext = rhs.pNext; + objectType = rhs.objectType; + object = rhs.object; + pObjectName = rhs.pObjectName; + return *this; } @@ -37276,8 +37483,13 @@ namespace VULKAN_HPP_NAMESPACE DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DebugMarkerObjectTagInfoEXT ) - offsetof( DebugMarkerObjectTagInfoEXT, pNext ) ); + pNext = rhs.pNext; + objectType = rhs.objectType; + object = rhs.object; + tagName = rhs.tagName; + tagSize = rhs.tagSize; + pTag = rhs.pTag; + return *this; } @@ -37404,9 +37616,11 @@ namespace VULKAN_HPP_NAMESPACE DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DebugReportCallbackCreateInfoEXT ) - offsetof( DebugReportCallbackCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pfnCallback = rhs.pfnCallback; + pUserData = rhs.pUserData; + return *this; } @@ -37503,7 +37717,10 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DebugUtilsLabelEXT ) - offsetof( DebugUtilsLabelEXT, pNext ) ); + pNext = rhs.pNext; + pLabelName = rhs.pLabelName; + color = rhs.color; + return *this; } @@ -37595,8 +37812,11 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DebugUtilsObjectNameInfoEXT ) - offsetof( DebugUtilsObjectNameInfoEXT, pNext ) ); + pNext = rhs.pNext; + objectType = rhs.objectType; + objectHandle = rhs.objectHandle; + pObjectName = rhs.pObjectName; + return *this; } @@ -37737,9 +37957,18 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DebugUtilsMessengerCallbackDataEXT ) - offsetof( DebugUtilsMessengerCallbackDataEXT, pNext ) ); + 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; } @@ -37933,9 +38162,13 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DebugUtilsMessengerCreateInfoEXT ) - offsetof( DebugUtilsMessengerCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + messageSeverity = rhs.messageSeverity; + messageType = rhs.messageType; + pfnUserCallback = rhs.pfnUserCallback; + pUserData = rhs.pUserData; + return *this; } @@ -38072,8 +38305,13 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DebugUtilsObjectTagInfoEXT ) - offsetof( DebugUtilsObjectTagInfoEXT, pNext ) ); + pNext = rhs.pNext; + objectType = rhs.objectType; + objectHandle = rhs.objectHandle; + tagName = rhs.tagName; + tagSize = rhs.tagSize; + pTag = rhs.pTag; + return *this; } @@ -38197,10 +38435,9 @@ namespace VULKAN_HPP_NAMESPACE DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DedicatedAllocationBufferCreateInfoNV ) - - offsetof( DedicatedAllocationBufferCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + dedicatedAllocation = rhs.dedicatedAllocation; + return *this; } @@ -38285,10 +38522,9 @@ namespace VULKAN_HPP_NAMESPACE DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DedicatedAllocationImageCreateInfoNV ) - - offsetof( DedicatedAllocationImageCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + dedicatedAllocation = rhs.dedicatedAllocation; + return *this; } @@ -38375,10 +38611,10 @@ namespace VULKAN_HPP_NAMESPACE DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DedicatedAllocationMemoryAllocateInfoNV ) - - offsetof( DedicatedAllocationMemoryAllocateInfoNV, pNext ) ); + pNext = rhs.pNext; + image = rhs.image; + buffer = rhs.buffer; + return *this; } @@ -38468,7 +38704,9 @@ namespace VULKAN_HPP_NAMESPACE DeferredOperationInfoKHR & operator=( DeferredOperationInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeferredOperationInfoKHR ) - offsetof( DeferredOperationInfoKHR, pNext ) ); + pNext = rhs.pNext; + operationHandle = rhs.operationHandle; + return *this; } @@ -38783,7 +39021,12 @@ namespace VULKAN_HPP_NAMESPACE DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DescriptorPoolCreateInfo ) - offsetof( DescriptorPoolCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + maxSets = rhs.maxSets; + poolSizeCount = rhs.poolSizeCount; + pPoolSizes = rhs.pPoolSizes; + return *this; } @@ -38901,10 +39144,9 @@ namespace VULKAN_HPP_NAMESPACE DescriptorPoolInlineUniformBlockCreateInfoEXT & operator=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorPoolInlineUniformBlockCreateInfoEXT ) - - offsetof( DescriptorPoolInlineUniformBlockCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + maxInlineUniformBlockBindings = rhs.maxInlineUniformBlockBindings; + return *this; } @@ -39003,7 +39245,11 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DescriptorSetAllocateInfo ) - offsetof( DescriptorSetAllocateInfo, pNext ) ); + pNext = rhs.pNext; + descriptorPool = rhs.descriptorPool; + descriptorSetCount = rhs.descriptorSetCount; + pSetLayouts = rhs.pSetLayouts; + return *this; } @@ -39249,10 +39495,10 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorSetLayoutBindingFlagsCreateInfo ) - - offsetof( DescriptorSetLayoutBindingFlagsCreateInfo, pNext ) ); + pNext = rhs.pNext; + bindingCount = rhs.bindingCount; + pBindingFlags = rhs.pBindingFlags; + return *this; } @@ -39367,9 +39613,11 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorSetLayoutCreateInfo ) - offsetof( DescriptorSetLayoutCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + bindingCount = rhs.bindingCount; + pBindings = rhs.pBindings; + return *this; } @@ -39477,8 +39725,9 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DescriptorSetLayoutSupport ) - offsetof( DescriptorSetLayoutSupport, pNext ) ); + pNext = rhs.pNext; + supported = rhs.supported; + return *this; } @@ -39561,10 +39810,10 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorSetVariableDescriptorCountAllocateInfo ) - - offsetof( DescriptorSetVariableDescriptorCountAllocateInfo, pNext ) ); + pNext = rhs.pNext; + descriptorSetCount = rhs.descriptorSetCount; + pDescriptorCounts = rhs.pDescriptorCounts; + return *this; } @@ -39671,10 +39920,9 @@ namespace VULKAN_HPP_NAMESPACE DescriptorSetVariableDescriptorCountLayoutSupport & operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorSetVariableDescriptorCountLayoutSupport ) - - offsetof( DescriptorSetVariableDescriptorCountLayoutSupport, pNext ) ); + pNext = rhs.pNext; + maxVariableDescriptorCount = rhs.maxVariableDescriptorCount; + return *this; } @@ -39890,9 +40138,16 @@ namespace VULKAN_HPP_NAMESPACE DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DescriptorUpdateTemplateCreateInfo ) - offsetof( DescriptorUpdateTemplateCreateInfo, pNext ) ); + 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; } @@ -40061,7 +40316,12 @@ namespace VULKAN_HPP_NAMESPACE DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceQueueCreateInfo ) - offsetof( DeviceQueueCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + queueFamilyIndex = rhs.queueFamilyIndex; + queueCount = rhs.queueCount; + pQueuePriorities = rhs.pQueuePriorities; + return *this; } @@ -40823,7 +41083,16 @@ namespace VULKAN_HPP_NAMESPACE DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceCreateInfo ) - offsetof( DeviceCreateInfo, pNext ) ); + 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; } @@ -40992,9 +41261,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceDiagnosticsConfigCreateInfoNV & operator=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceDiagnosticsConfigCreateInfoNV ) - offsetof( DeviceDiagnosticsConfigCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -41077,7 +41346,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceEventInfoEXT & operator=( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceEventInfoEXT ) - offsetof( DeviceEventInfoEXT, pNext ) ); + pNext = rhs.pNext; + deviceEvent = rhs.deviceEvent; + return *this; } @@ -41158,7 +41429,10 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupBindSparseInfo & operator=( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupBindSparseInfo ) - offsetof( DeviceGroupBindSparseInfo, pNext ) ); + pNext = rhs.pNext; + resourceDeviceIndex = rhs.resourceDeviceIndex; + memoryDeviceIndex = rhs.memoryDeviceIndex; + return *this; } @@ -41247,9 +41521,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupCommandBufferBeginInfo & operator=( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceGroupCommandBufferBeginInfo ) - offsetof( DeviceGroupCommandBufferBeginInfo, pNext ) ); + pNext = rhs.pNext; + deviceMask = rhs.deviceMask; + return *this; } @@ -41341,8 +41615,10 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupDeviceCreateInfo & operator=( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DeviceGroupDeviceCreateInfo ) - offsetof( DeviceGroupDeviceCreateInfo, pNext ) ); + pNext = rhs.pNext; + physicalDeviceCount = rhs.physicalDeviceCount; + pPhysicalDevices = rhs.pPhysicalDevices; + return *this; } @@ -41446,9 +41722,10 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupPresentCapabilitiesKHR & operator=( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceGroupPresentCapabilitiesKHR ) - offsetof( DeviceGroupPresentCapabilitiesKHR, pNext ) ); + pNext = rhs.pNext; + presentMask = rhs.presentMask; + modes = rhs.modes; + return *this; } @@ -41534,7 +41811,11 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupPresentInfoKHR & operator=( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupPresentInfoKHR ) - offsetof( DeviceGroupPresentInfoKHR, pNext ) ); + pNext = rhs.pNext; + swapchainCount = rhs.swapchainCount; + pDeviceMasks = rhs.pDeviceMasks; + mode = rhs.mode; + return *this; } @@ -41656,9 +41937,11 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupRenderPassBeginInfo & operator=( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceGroupRenderPassBeginInfo ) - offsetof( DeviceGroupRenderPassBeginInfo, pNext ) ); + pNext = rhs.pNext; + deviceMask = rhs.deviceMask; + deviceRenderAreaCount = rhs.deviceRenderAreaCount; + pDeviceRenderAreas = rhs.pDeviceRenderAreas; + return *this; } @@ -41790,7 +42073,14 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupSubmitInfo & operator=( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceGroupSubmitInfo ) - offsetof( DeviceGroupSubmitInfo, pNext ) ); + pNext = rhs.pNext; + waitSemaphoreCount = rhs.waitSemaphoreCount; + pWaitSemaphoreDeviceIndices = rhs.pWaitSemaphoreDeviceIndices; + commandBufferCount = rhs.commandBufferCount; + pCommandBufferDeviceMasks = rhs.pCommandBufferDeviceMasks; + signalSemaphoreCount = rhs.signalSemaphoreCount; + pSignalSemaphoreDeviceIndices = rhs.pSignalSemaphoreDeviceIndices; + return *this; } @@ -41946,9 +42236,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceGroupSwapchainCreateInfoKHR & operator=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceGroupSwapchainCreateInfoKHR ) - offsetof( DeviceGroupSwapchainCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + modes = rhs.modes; + return *this; } @@ -42033,10 +42323,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemoryOpaqueCaptureAddressInfo & operator=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceMemoryOpaqueCaptureAddressInfo ) - - offsetof( DeviceMemoryOpaqueCaptureAddressInfo, pNext ) ); + pNext = rhs.pNext; + memory = rhs.memory; + return *this; } @@ -42121,10 +42410,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemoryOverallocationCreateInfoAMD & operator=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceMemoryOverallocationCreateInfoAMD ) - - offsetof( DeviceMemoryOverallocationCreateInfoAMD, pNext ) ); + pNext = rhs.pNext; + overallocationBehavior = rhs.overallocationBehavior; + return *this; } @@ -42209,9 +42497,9 @@ namespace VULKAN_HPP_NAMESPACE DevicePrivateDataCreateInfoEXT & operator=( DevicePrivateDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DevicePrivateDataCreateInfoEXT ) - offsetof( DevicePrivateDataCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + privateDataSlotRequestCount = rhs.privateDataSlotRequestCount; + return *this; } @@ -42298,10 +42586,9 @@ namespace VULKAN_HPP_NAMESPACE DeviceQueueGlobalPriorityCreateInfoEXT & operator=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) - - offsetof( DeviceQueueGlobalPriorityCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + globalPriority = rhs.globalPriority; + return *this; } @@ -42386,7 +42673,11 @@ namespace VULKAN_HPP_NAMESPACE DeviceQueueInfo2 & operator=( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DeviceQueueInfo2 ) - offsetof( DeviceQueueInfo2, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + queueFamilyIndex = rhs.queueFamilyIndex; + queueIndex = rhs.queueIndex; + return *this; } @@ -42485,8 +42776,11 @@ namespace VULKAN_HPP_NAMESPACE DirectFBSurfaceCreateInfoEXT & operator=( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DirectFBSurfaceCreateInfoEXT ) - offsetof( DirectFBSurfaceCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + dfb = rhs.dfb; + surface = rhs.surface; + return *this; } @@ -42658,7 +42952,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayEventInfoEXT ) - offsetof( DisplayEventInfoEXT, pNext ) ); + pNext = rhs.pNext; + displayEvent = rhs.displayEvent; + return *this; } @@ -42806,7 +43102,10 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeCreateInfoKHR ) - offsetof( DisplayModeCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + parameters = rhs.parameters; + return *this; } @@ -42949,7 +43248,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayModeProperties2KHR ) - offsetof( DisplayModeProperties2KHR, pNext ) ); + pNext = rhs.pNext; + displayModeProperties = rhs.displayModeProperties; + return *this; } @@ -43021,10 +43322,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DisplayNativeHdrSurfaceCapabilitiesAMD ) - - offsetof( DisplayNativeHdrSurfaceCapabilitiesAMD, pNext ) ); + pNext = rhs.pNext; + localDimmingSupport = rhs.localDimmingSupport; + return *this; } @@ -43173,8 +43473,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DisplayPlaneCapabilities2KHR ) - offsetof( DisplayPlaneCapabilities2KHR, pNext ) ); + pNext = rhs.pNext; + capabilities = rhs.capabilities; + return *this; } @@ -43244,7 +43545,10 @@ namespace VULKAN_HPP_NAMESPACE DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayPlaneInfo2KHR ) - offsetof( DisplayPlaneInfo2KHR, pNext ) ); + pNext = rhs.pNext; + mode = rhs.mode; + planeIndex = rhs.planeIndex; + return *this; } @@ -43386,8 +43690,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DisplayPlaneProperties2KHR ) - offsetof( DisplayPlaneProperties2KHR, pNext ) ); + pNext = rhs.pNext; + displayPlaneProperties = rhs.displayPlaneProperties; + return *this; } @@ -43457,7 +43762,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayPowerInfoEXT ) - offsetof( DisplayPowerInfoEXT, pNext ) ); + pNext = rhs.pNext; + powerState = rhs.powerState; + return *this; } @@ -43540,7 +43847,11 @@ namespace VULKAN_HPP_NAMESPACE DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayPresentInfoKHR ) - offsetof( DisplayPresentInfoKHR, pNext ) ); + pNext = rhs.pNext; + srcRect = rhs.srcRect; + dstRect = rhs.dstRect; + persistent = rhs.persistent; + return *this; } @@ -43707,7 +44018,9 @@ namespace VULKAN_HPP_NAMESPACE DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( DisplayProperties2KHR ) - offsetof( DisplayProperties2KHR, pNext ) ); + pNext = rhs.pNext; + displayProperties = rhs.displayProperties; + return *this; } @@ -43791,8 +44104,16 @@ namespace VULKAN_HPP_NAMESPACE DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( DisplaySurfaceCreateInfoKHR ) - offsetof( DisplaySurfaceCreateInfoKHR, pNext ) ); + 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; } @@ -44250,9 +44571,10 @@ namespace VULKAN_HPP_NAMESPACE DrmFormatModifierPropertiesListEXT & operator=( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( DrmFormatModifierPropertiesListEXT ) - offsetof( DrmFormatModifierPropertiesListEXT, pNext ) ); + pNext = rhs.pNext; + drmFormatModifierCount = rhs.drmFormatModifierCount; + pDrmFormatModifierProperties = rhs.pDrmFormatModifierProperties; + return *this; } @@ -44323,7 +44645,9 @@ namespace VULKAN_HPP_NAMESPACE EventCreateInfo & operator=( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( EventCreateInfo ) - offsetof( EventCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -44402,7 +44726,9 @@ namespace VULKAN_HPP_NAMESPACE ExportFenceCreateInfo & operator=( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExportFenceCreateInfo ) - offsetof( ExportFenceCreateInfo, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -44487,9 +44813,11 @@ namespace VULKAN_HPP_NAMESPACE ExportFenceWin32HandleInfoKHR & operator=( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExportFenceWin32HandleInfoKHR ) - offsetof( ExportFenceWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + pAttributes = rhs.pAttributes; + dwAccess = rhs.dwAccess; + name = rhs.name; + return *this; } @@ -44586,7 +44914,9 @@ namespace VULKAN_HPP_NAMESPACE ExportMemoryAllocateInfo & operator=( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExportMemoryAllocateInfo ) - offsetof( ExportMemoryAllocateInfo, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -44667,8 +44997,9 @@ namespace VULKAN_HPP_NAMESPACE ExportMemoryAllocateInfoNV & operator=( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ExportMemoryAllocateInfoNV ) - offsetof( ExportMemoryAllocateInfoNV, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -44754,9 +45085,11 @@ namespace VULKAN_HPP_NAMESPACE ExportMemoryWin32HandleInfoKHR & operator=( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExportMemoryWin32HandleInfoKHR ) - offsetof( ExportMemoryWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + pAttributes = rhs.pAttributes; + dwAccess = rhs.dwAccess; + name = rhs.name; + return *this; } @@ -44855,9 +45188,10 @@ namespace VULKAN_HPP_NAMESPACE ExportMemoryWin32HandleInfoNV & operator=( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExportMemoryWin32HandleInfoNV ) - offsetof( ExportMemoryWin32HandleInfoNV, pNext ) ); + pNext = rhs.pNext; + pAttributes = rhs.pAttributes; + dwAccess = rhs.dwAccess; + return *this; } @@ -44947,7 +45281,9 @@ namespace VULKAN_HPP_NAMESPACE ExportSemaphoreCreateInfo & operator=( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExportSemaphoreCreateInfo ) - offsetof( ExportSemaphoreCreateInfo, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -45034,9 +45370,11 @@ namespace VULKAN_HPP_NAMESPACE ExportSemaphoreWin32HandleInfoKHR & operator=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExportSemaphoreWin32HandleInfoKHR ) - offsetof( ExportSemaphoreWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + pAttributes = rhs.pAttributes; + dwAccess = rhs.dwAccess; + name = rhs.name; + return *this; } @@ -45246,7 +45584,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalBufferProperties & operator=( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExternalBufferProperties ) - offsetof( ExternalBufferProperties, pNext ) ); + pNext = rhs.pNext; + externalMemoryProperties = rhs.externalMemoryProperties; + return *this; } @@ -45319,7 +45659,11 @@ namespace VULKAN_HPP_NAMESPACE ExternalFenceProperties & operator=( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExternalFenceProperties ) - offsetof( ExternalFenceProperties, pNext ) ); + pNext = rhs.pNext; + exportFromImportedHandleTypes = rhs.exportFromImportedHandleTypes; + compatibleHandleTypes = rhs.compatibleHandleTypes; + externalFenceFeatures = rhs.externalFenceFeatures; + return *this; } @@ -45392,7 +45736,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalFormatANDROID & operator=( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ExternalFormatANDROID ) - offsetof( ExternalFormatANDROID, pNext ) ); + pNext = rhs.pNext; + externalFormat = rhs.externalFormat; + return *this; } @@ -45473,9 +45819,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalImageFormatProperties & operator=( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExternalImageFormatProperties ) - offsetof( ExternalImageFormatProperties, pNext ) ); + pNext = rhs.pNext; + externalMemoryProperties = rhs.externalMemoryProperties; + return *this; } @@ -45674,9 +46020,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalMemoryBufferCreateInfo & operator=( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExternalMemoryBufferCreateInfo ) - offsetof( ExternalMemoryBufferCreateInfo, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -45758,9 +46104,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalMemoryImageCreateInfo & operator=( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExternalMemoryImageCreateInfo ) - offsetof( ExternalMemoryImageCreateInfo, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -45842,9 +46188,9 @@ namespace VULKAN_HPP_NAMESPACE ExternalMemoryImageCreateInfoNV & operator=( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ExternalMemoryImageCreateInfoNV ) - offsetof( ExternalMemoryImageCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + handleTypes = rhs.handleTypes; + return *this; } @@ -45930,8 +46276,11 @@ namespace VULKAN_HPP_NAMESPACE ExternalSemaphoreProperties & operator=( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ExternalSemaphoreProperties ) - offsetof( ExternalSemaphoreProperties, pNext ) ); + pNext = rhs.pNext; + exportFromImportedHandleTypes = rhs.exportFromImportedHandleTypes; + compatibleHandleTypes = rhs.compatibleHandleTypes; + externalSemaphoreFeatures = rhs.externalSemaphoreFeatures; + return *this; } @@ -46004,7 +46353,9 @@ namespace VULKAN_HPP_NAMESPACE FenceCreateInfo & operator=( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( FenceCreateInfo ) - offsetof( FenceCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -46086,7 +46437,10 @@ namespace VULKAN_HPP_NAMESPACE FenceGetFdInfoKHR & operator=( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( FenceGetFdInfoKHR ) - offsetof( FenceGetFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + fence = rhs.fence; + handleType = rhs.handleType; + return *this; } @@ -46180,8 +46534,10 @@ namespace VULKAN_HPP_NAMESPACE FenceGetWin32HandleInfoKHR & operator=( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( FenceGetWin32HandleInfoKHR ) - offsetof( FenceGetWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + fence = rhs.fence; + handleType = rhs.handleType; + return *this; } @@ -46279,10 +46635,10 @@ namespace VULKAN_HPP_NAMESPACE FilterCubicImageViewImageFormatPropertiesEXT & operator=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( FilterCubicImageViewImageFormatPropertiesEXT ) - - offsetof( FilterCubicImageViewImageFormatPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + filterCubic = rhs.filterCubic; + filterCubicMinmax = rhs.filterCubicMinmax; + return *this; } @@ -46412,7 +46768,9 @@ namespace VULKAN_HPP_NAMESPACE FormatProperties2 & operator=( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( FormatProperties2 ) - offsetof( FormatProperties2, pNext ) ); + pNext = rhs.pNext; + formatProperties = rhs.formatProperties; + return *this; } @@ -46510,9 +46868,15 @@ namespace VULKAN_HPP_NAMESPACE FramebufferAttachmentImageInfo & operator=( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( FramebufferAttachmentImageInfo ) - offsetof( FramebufferAttachmentImageInfo, pNext ) ); + 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; } @@ -46660,9 +47024,10 @@ namespace VULKAN_HPP_NAMESPACE FramebufferAttachmentsCreateInfo & operator=( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( FramebufferAttachmentsCreateInfo ) - offsetof( FramebufferAttachmentsCreateInfo, pNext ) ); + pNext = rhs.pNext; + attachmentImageInfoCount = rhs.attachmentImageInfoCount; + pAttachmentImageInfos = rhs.pAttachmentImageInfos; + return *this; } @@ -46794,7 +47159,15 @@ namespace VULKAN_HPP_NAMESPACE FramebufferCreateInfo & operator=( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( FramebufferCreateInfo ) - offsetof( FramebufferCreateInfo, pNext ) ); + 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; } @@ -46940,10 +47313,12 @@ namespace VULKAN_HPP_NAMESPACE FramebufferMixedSamplesCombinationNV & operator=( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( FramebufferMixedSamplesCombinationNV ) - - offsetof( FramebufferMixedSamplesCombinationNV, pNext ) ); + pNext = rhs.pNext; + coverageReductionMode = rhs.coverageReductionMode; + rasterizationSamples = rhs.rasterizationSamples; + depthStencilSamples = rhs.depthStencilSamples; + colorSamples = rhs.colorSamples; + return *this; } @@ -47139,7 +47514,21 @@ namespace VULKAN_HPP_NAMESPACE GeneratedCommandsInfoNV & operator=( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( GeneratedCommandsInfoNV ) - offsetof( GeneratedCommandsInfoNV, pNext ) ); + 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; } @@ -47340,10 +47729,12 @@ namespace VULKAN_HPP_NAMESPACE GeneratedCommandsMemoryRequirementsInfoNV & operator=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( GeneratedCommandsMemoryRequirementsInfoNV ) - - offsetof( GeneratedCommandsMemoryRequirementsInfoNV, pNext ) ); + pNext = rhs.pNext; + pipelineBindPoint = rhs.pipelineBindPoint; + pipeline = rhs.pipeline; + indirectCommandsLayout = rhs.indirectCommandsLayout; + maxSequencesCount = rhs.maxSequencesCount; + return *this; } @@ -47640,9 +48031,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineVertexInputStateCreateInfo ) - offsetof( PipelineVertexInputStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + vertexBindingDescriptionCount = rhs.vertexBindingDescriptionCount; + pVertexBindingDescriptions = rhs.pVertexBindingDescriptions; + vertexAttributeDescriptionCount = rhs.vertexAttributeDescriptionCount; + pVertexAttributeDescriptions = rhs.pVertexAttributeDescriptions; + return *this; } @@ -47789,10 +48184,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineInputAssemblyStateCreateInfo ) - - offsetof( PipelineInputAssemblyStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + topology = rhs.topology; + primitiveRestartEnable = rhs.primitiveRestartEnable; + return *this; } @@ -47896,9 +48292,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineTessellationStateCreateInfo ) - offsetof( PipelineTessellationStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + patchControlPoints = rhs.patchControlPoints; + return *this; } @@ -48110,9 +48507,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportStateCreateInfo ) - offsetof( PipelineViewportStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + viewportCount = rhs.viewportCount; + pViewports = rhs.pViewports; + scissorCount = rhs.scissorCount; + pScissors = rhs.pScissors; + return *this; } @@ -48271,10 +48672,19 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationStateCreateInfo ) - - offsetof( PipelineRasterizationStateCreateInfo, pNext ) ); + 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; } @@ -48453,9 +48863,15 @@ namespace VULKAN_HPP_NAMESPACE PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineMultisampleStateCreateInfo ) - offsetof( PipelineMultisampleStateCreateInfo, pNext ) ); + 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; } @@ -48721,9 +49137,18 @@ namespace VULKAN_HPP_NAMESPACE PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineDepthStencilStateCreateInfo ) - offsetof( PipelineDepthStencilStateCreateInfo, pNext ) ); + 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; } @@ -49038,9 +49463,14 @@ namespace VULKAN_HPP_NAMESPACE PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineColorBlendStateCreateInfo ) - offsetof( PipelineColorBlendStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + logicOpEnable = rhs.logicOpEnable; + logicOp = rhs.logicOp; + attachmentCount = rhs.attachmentCount; + pAttachments = rhs.pAttachments; + blendConstants = rhs.blendConstants; + return *this; } @@ -49187,9 +49617,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineDynamicStateCreateInfo ) - offsetof( PipelineDynamicStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + dynamicStateCount = rhs.dynamicStateCount; + pDynamicStates = rhs.pDynamicStates; + return *this; } @@ -49369,8 +49801,25 @@ namespace VULKAN_HPP_NAMESPACE GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( GraphicsPipelineCreateInfo ) - offsetof( GraphicsPipelineCreateInfo, pNext ) ); + 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; } @@ -49612,9 +50061,12 @@ namespace VULKAN_HPP_NAMESPACE GraphicsShaderGroupCreateInfoNV & operator=( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( GraphicsShaderGroupCreateInfoNV ) - offsetof( GraphicsShaderGroupCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + stageCount = rhs.stageCount; + pStages = rhs.pStages; + pVertexInputState = rhs.pVertexInputState; + pTessellationState = rhs.pTessellationState; + return *this; } @@ -49754,10 +50206,12 @@ namespace VULKAN_HPP_NAMESPACE GraphicsPipelineShaderGroupsCreateInfoNV & operator=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( GraphicsPipelineShaderGroupsCreateInfoNV ) - - offsetof( GraphicsPipelineShaderGroupsCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + groupCount = rhs.groupCount; + pGroups = rhs.pGroups; + pipelineCount = rhs.pipelineCount; + pPipelines = rhs.pPipelines; + return *this; } @@ -49961,7 +50415,16 @@ namespace VULKAN_HPP_NAMESPACE HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( HdrMetadataEXT ) - offsetof( HdrMetadataEXT, pNext ) ); + 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; } @@ -50095,8 +50558,9 @@ namespace VULKAN_HPP_NAMESPACE HeadlessSurfaceCreateInfoEXT & operator=( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( HeadlessSurfaceCreateInfoEXT ) - offsetof( HeadlessSurfaceCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -50180,7 +50644,10 @@ namespace VULKAN_HPP_NAMESPACE IOSSurfaceCreateInfoMVK & operator=( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( IOSSurfaceCreateInfoMVK ) - offsetof( IOSSurfaceCreateInfoMVK, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pView = rhs.pView; + return *this; } @@ -50502,7 +50969,21 @@ namespace VULKAN_HPP_NAMESPACE ImageCreateInfo & operator=( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageCreateInfo ) - offsetof( ImageCreateInfo, pNext ) ); + 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; } @@ -50762,10 +51243,11 @@ namespace VULKAN_HPP_NAMESPACE ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImageDrmFormatModifierExplicitCreateInfoEXT ) - - offsetof( ImageDrmFormatModifierExplicitCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + drmFormatModifier = rhs.drmFormatModifier; + drmFormatModifierPlaneCount = rhs.drmFormatModifierPlaneCount; + pPlaneLayouts = rhs.pPlaneLayouts; + return *this; } @@ -50890,10 +51372,10 @@ namespace VULKAN_HPP_NAMESPACE ImageDrmFormatModifierListCreateInfoEXT & operator=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImageDrmFormatModifierListCreateInfoEXT ) - - offsetof( ImageDrmFormatModifierListCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + drmFormatModifierCount = rhs.drmFormatModifierCount; + pDrmFormatModifiers = rhs.pDrmFormatModifiers; + return *this; } @@ -50998,9 +51480,9 @@ namespace VULKAN_HPP_NAMESPACE ImageDrmFormatModifierPropertiesEXT & operator=( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImageDrmFormatModifierPropertiesEXT ) - offsetof( ImageDrmFormatModifierPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + drmFormatModifier = rhs.drmFormatModifier; + return *this; } @@ -51078,7 +51560,10 @@ namespace VULKAN_HPP_NAMESPACE ImageFormatListCreateInfo & operator=( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageFormatListCreateInfo ) - offsetof( ImageFormatListCreateInfo, pNext ) ); + pNext = rhs.pNext; + viewFormatCount = rhs.viewFormatCount; + pViewFormats = rhs.pViewFormats; + return *this; } @@ -51179,7 +51664,9 @@ namespace VULKAN_HPP_NAMESPACE ImageFormatProperties2 & operator=( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageFormatProperties2 ) - offsetof( ImageFormatProperties2, pNext ) ); + pNext = rhs.pNext; + imageFormatProperties = rhs.imageFormatProperties; + return *this; } @@ -51355,7 +51842,16 @@ namespace VULKAN_HPP_NAMESPACE ImageMemoryBarrier & operator=( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageMemoryBarrier ) - offsetof( ImageMemoryBarrier, pNext ) ); + 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; } @@ -51488,8 +51984,9 @@ namespace VULKAN_HPP_NAMESPACE ImageMemoryRequirementsInfo2 & operator=( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ImageMemoryRequirementsInfo2 ) - offsetof( ImageMemoryRequirementsInfo2, pNext ) ); + pNext = rhs.pNext; + image = rhs.image; + return *this; } @@ -51574,9 +52071,10 @@ namespace VULKAN_HPP_NAMESPACE ImagePipeSurfaceCreateInfoFUCHSIA & operator=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImagePipeSurfaceCreateInfoFUCHSIA ) - offsetof( ImagePipeSurfaceCreateInfoFUCHSIA, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + imagePipeHandle = rhs.imagePipeHandle; + return *this; } @@ -51668,9 +52166,9 @@ namespace VULKAN_HPP_NAMESPACE ImagePlaneMemoryRequirementsInfo & operator=( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImagePlaneMemoryRequirementsInfo ) - offsetof( ImagePlaneMemoryRequirementsInfo, pNext ) ); + pNext = rhs.pNext; + planeAspect = rhs.planeAspect; + return *this; } @@ -51848,9 +52346,9 @@ namespace VULKAN_HPP_NAMESPACE ImageSparseMemoryRequirementsInfo2 & operator=( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImageSparseMemoryRequirementsInfo2 ) - offsetof( ImageSparseMemoryRequirementsInfo2, pNext ) ); + pNext = rhs.pNext; + image = rhs.image; + return *this; } @@ -51931,8 +52429,9 @@ namespace VULKAN_HPP_NAMESPACE ImageStencilUsageCreateInfo & operator=( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ImageStencilUsageCreateInfo ) - offsetof( ImageStencilUsageCreateInfo, pNext ) ); + pNext = rhs.pNext; + stencilUsage = rhs.stencilUsage; + return *this; } @@ -52014,8 +52513,9 @@ namespace VULKAN_HPP_NAMESPACE ImageSwapchainCreateInfoKHR & operator=( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ImageSwapchainCreateInfoKHR ) - offsetof( ImageSwapchainCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + swapchain = rhs.swapchain; + return *this; } @@ -52096,8 +52596,9 @@ namespace VULKAN_HPP_NAMESPACE ImageViewASTCDecodeModeEXT & operator=( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ImageViewASTCDecodeModeEXT ) - offsetof( ImageViewASTCDecodeModeEXT, pNext ) ); + pNext = rhs.pNext; + decodeMode = rhs.decodeMode; + return *this; } @@ -52180,9 +52681,10 @@ namespace VULKAN_HPP_NAMESPACE ImageViewAddressPropertiesNVX & operator=( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImageViewAddressPropertiesNVX ) - offsetof( ImageViewAddressPropertiesNVX, pNext ) ); + pNext = rhs.pNext; + deviceAddress = rhs.deviceAddress; + size = rhs.size; + return *this; } @@ -52263,7 +52765,14 @@ namespace VULKAN_HPP_NAMESPACE ImageViewCreateInfo & operator=( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageViewCreateInfo ) - offsetof( ImageViewCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + image = rhs.image; + viewType = rhs.viewType; + format = rhs.format; + components = rhs.components; + subresourceRange = rhs.subresourceRange; + return *this; } @@ -52386,7 +52895,11 @@ namespace VULKAN_HPP_NAMESPACE ImageViewHandleInfoNVX & operator=( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageViewHandleInfoNVX ) - offsetof( ImageViewHandleInfoNVX, pNext ) ); + pNext = rhs.pNext; + imageView = rhs.imageView; + descriptorType = rhs.descriptorType; + sampler = rhs.sampler; + return *this; } @@ -52482,7 +52995,9 @@ namespace VULKAN_HPP_NAMESPACE ImageViewUsageCreateInfo & operator=( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImageViewUsageCreateInfo ) - offsetof( ImageViewUsageCreateInfo, pNext ) ); + pNext = rhs.pNext; + usage = rhs.usage; + return *this; } @@ -52566,10 +53081,9 @@ namespace VULKAN_HPP_NAMESPACE ImportAndroidHardwareBufferInfoANDROID & operator=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportAndroidHardwareBufferInfoANDROID ) - - offsetof( ImportAndroidHardwareBufferInfoANDROID, pNext ) ); + pNext = rhs.pNext; + buffer = rhs.buffer; + return *this; } @@ -52657,7 +53171,12 @@ namespace VULKAN_HPP_NAMESPACE ImportFenceFdInfoKHR & operator=( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImportFenceFdInfoKHR ) - offsetof( ImportFenceFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + fence = rhs.fence; + flags = rhs.flags; + handleType = rhs.handleType; + fd = rhs.fd; + return *this; } @@ -52771,9 +53290,13 @@ namespace VULKAN_HPP_NAMESPACE ImportFenceWin32HandleInfoKHR & operator=( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportFenceWin32HandleInfoKHR ) - offsetof( ImportFenceWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + fence = rhs.fence; + flags = rhs.flags; + handleType = rhs.handleType; + handle = rhs.handle; + name = rhs.name; + return *this; } @@ -52888,7 +53411,10 @@ namespace VULKAN_HPP_NAMESPACE ImportMemoryFdInfoKHR & operator=( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImportMemoryFdInfoKHR ) - offsetof( ImportMemoryFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + fd = rhs.fd; + return *this; } @@ -52980,9 +53506,10 @@ namespace VULKAN_HPP_NAMESPACE ImportMemoryHostPointerInfoEXT & operator=( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportMemoryHostPointerInfoEXT ) - offsetof( ImportMemoryHostPointerInfoEXT, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + pHostPointer = rhs.pHostPointer; + return *this; } @@ -53079,9 +53606,11 @@ namespace VULKAN_HPP_NAMESPACE ImportMemoryWin32HandleInfoKHR & operator=( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportMemoryWin32HandleInfoKHR ) - offsetof( ImportMemoryWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + handle = rhs.handle; + name = rhs.name; + return *this; } @@ -53183,9 +53712,10 @@ namespace VULKAN_HPP_NAMESPACE ImportMemoryWin32HandleInfoNV & operator=( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportMemoryWin32HandleInfoNV ) - offsetof( ImportMemoryWin32HandleInfoNV, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + handle = rhs.handle; + return *this; } @@ -53283,7 +53813,12 @@ namespace VULKAN_HPP_NAMESPACE ImportSemaphoreFdInfoKHR & operator=( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ImportSemaphoreFdInfoKHR ) - offsetof( ImportSemaphoreFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + semaphore = rhs.semaphore; + flags = rhs.flags; + handleType = rhs.handleType; + fd = rhs.fd; + return *this; } @@ -53398,9 +53933,13 @@ namespace VULKAN_HPP_NAMESPACE ImportSemaphoreWin32HandleInfoKHR & operator=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ImportSemaphoreWin32HandleInfoKHR ) - offsetof( ImportSemaphoreWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + semaphore = rhs.semaphore; + flags = rhs.flags; + handleType = rhs.handleType; + handle = rhs.handle; + name = rhs.name; + return *this; } @@ -53581,9 +54120,21 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutTokenNV & operator=( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( IndirectCommandsLayoutTokenNV ) - offsetof( IndirectCommandsLayoutTokenNV, pNext ) ); + 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; } @@ -53811,9 +54362,14 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutCreateInfoNV & operator=( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( IndirectCommandsLayoutCreateInfoNV ) - offsetof( IndirectCommandsLayoutCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pipelineBindPoint = rhs.pipelineBindPoint; + tokenCount = rhs.tokenCount; + pTokens = rhs.pTokens; + streamCount = rhs.streamCount; + pStreamStrides = rhs.pStreamStrides; + return *this; } @@ -53956,9 +54512,9 @@ namespace VULKAN_HPP_NAMESPACE InitializePerformanceApiInfoINTEL & operator=( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( InitializePerformanceApiInfoINTEL ) - offsetof( InitializePerformanceApiInfoINTEL, pNext ) ); + pNext = rhs.pNext; + pUserData = rhs.pUserData; + return *this; } @@ -54141,7 +54697,14 @@ namespace VULKAN_HPP_NAMESPACE InstanceCreateInfo & operator=( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( InstanceCreateInfo ) - offsetof( InstanceCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pApplicationInfo = rhs.pApplicationInfo; + enabledLayerCount = rhs.enabledLayerCount; + ppEnabledLayerNames = rhs.ppEnabledLayerNames; + enabledExtensionCount = rhs.enabledExtensionCount; + ppEnabledExtensionNames = rhs.ppEnabledExtensionNames; + return *this; } @@ -54345,7 +54908,10 @@ namespace VULKAN_HPP_NAMESPACE MacOSSurfaceCreateInfoMVK & operator=( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MacOSSurfaceCreateInfoMVK ) - offsetof( MacOSSurfaceCreateInfoMVK, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pView = rhs.pView; + return *this; } @@ -54437,7 +55003,11 @@ namespace VULKAN_HPP_NAMESPACE MappedMemoryRange & operator=( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MappedMemoryRange ) - offsetof( MappedMemoryRange, pNext ) ); + pNext = rhs.pNext; + memory = rhs.memory; + offset = rhs.offset; + size = rhs.size; + return *this; } @@ -54533,7 +55103,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryAllocateFlagsInfo & operator=( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryAllocateFlagsInfo ) - offsetof( MemoryAllocateFlagsInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + deviceMask = rhs.deviceMask; + return *this; } @@ -54622,7 +55195,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryAllocateInfo & operator=( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryAllocateInfo ) - offsetof( MemoryAllocateInfo, pNext ) ); + pNext = rhs.pNext; + allocationSize = rhs.allocationSize; + memoryTypeIndex = rhs.memoryTypeIndex; + return *this; } @@ -54711,7 +55287,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryBarrier & operator=( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryBarrier ) - offsetof( MemoryBarrier, pNext ) ); + pNext = rhs.pNext; + srcAccessMask = rhs.srcAccessMask; + dstAccessMask = rhs.dstAccessMask; + return *this; } @@ -54799,8 +55378,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryDedicatedAllocateInfo & operator=( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( MemoryDedicatedAllocateInfo ) - offsetof( MemoryDedicatedAllocateInfo, pNext ) ); + pNext = rhs.pNext; + image = rhs.image; + buffer = rhs.buffer; + return *this; } @@ -54890,8 +55471,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryDedicatedRequirements & operator=( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( MemoryDedicatedRequirements ) - offsetof( MemoryDedicatedRequirements, pNext ) ); + pNext = rhs.pNext; + prefersDedicatedAllocation = rhs.prefersDedicatedAllocation; + requiresDedicatedAllocation = rhs.requiresDedicatedAllocation; + return *this; } @@ -54962,7 +55545,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryFdPropertiesKHR & operator=( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryFdPropertiesKHR ) - offsetof( MemoryFdPropertiesKHR, pNext ) ); + pNext = rhs.pNext; + memoryTypeBits = rhs.memoryTypeBits; + return *this; } @@ -55035,10 +55620,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryGetAndroidHardwareBufferInfoANDROID & operator=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( MemoryGetAndroidHardwareBufferInfoANDROID ) - - offsetof( MemoryGetAndroidHardwareBufferInfoANDROID, pNext ) ); + pNext = rhs.pNext; + memory = rhs.memory; + return *this; } @@ -55125,7 +55709,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryGetFdInfoKHR & operator=( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryGetFdInfoKHR ) - offsetof( MemoryGetFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + memory = rhs.memory; + handleType = rhs.handleType; + return *this; } @@ -55219,8 +55806,10 @@ namespace VULKAN_HPP_NAMESPACE MemoryGetWin32HandleInfoKHR & operator=( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( MemoryGetWin32HandleInfoKHR ) - offsetof( MemoryGetWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + memory = rhs.memory; + handleType = rhs.handleType; + return *this; } @@ -55363,9 +55952,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryHostPointerPropertiesEXT & operator=( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( MemoryHostPointerPropertiesEXT ) - offsetof( MemoryHostPointerPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + memoryTypeBits = rhs.memoryTypeBits; + return *this; } @@ -55437,10 +56026,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryOpaqueCaptureAddressAllocateInfo & operator=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( MemoryOpaqueCaptureAddressAllocateInfo ) - - offsetof( MemoryOpaqueCaptureAddressAllocateInfo, pNext ) ); + pNext = rhs.pNext; + opaqueCaptureAddress = rhs.opaqueCaptureAddress; + return *this; } @@ -55521,9 +56109,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryPriorityAllocateInfoEXT & operator=( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( MemoryPriorityAllocateInfoEXT ) - offsetof( MemoryPriorityAllocateInfoEXT, pNext ) ); + pNext = rhs.pNext; + priority = rhs.priority; + return *this; } @@ -55660,7 +56248,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryRequirements2 & operator=( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MemoryRequirements2 ) - offsetof( MemoryRequirements2, pNext ) ); + pNext = rhs.pNext; + memoryRequirements = rhs.memoryRequirements; + return *this; } @@ -55780,9 +56370,9 @@ namespace VULKAN_HPP_NAMESPACE MemoryWin32HandlePropertiesKHR & operator=( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( MemoryWin32HandlePropertiesKHR ) - offsetof( MemoryWin32HandlePropertiesKHR, pNext ) ); + pNext = rhs.pNext; + memoryTypeBits = rhs.memoryTypeBits; + return *this; } @@ -55854,7 +56444,10 @@ namespace VULKAN_HPP_NAMESPACE MetalSurfaceCreateInfoEXT & operator=( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MetalSurfaceCreateInfoEXT ) - offsetof( MetalSurfaceCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + pLayer = rhs.pLayer; + return *this; } @@ -55943,7 +56536,9 @@ namespace VULKAN_HPP_NAMESPACE MultisamplePropertiesEXT & operator=( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( MultisamplePropertiesEXT ) - offsetof( MultisamplePropertiesEXT, pNext ) ); + pNext = rhs.pNext; + maxSampleLocationGridSize = rhs.maxSampleLocationGridSize; + return *this; } @@ -56082,10 +56677,9 @@ namespace VULKAN_HPP_NAMESPACE PerformanceConfigurationAcquireInfoINTEL & operator=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PerformanceConfigurationAcquireInfoINTEL ) - - offsetof( PerformanceConfigurationAcquireInfoINTEL, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + return *this; } @@ -56175,9 +56769,12 @@ namespace VULKAN_HPP_NAMESPACE PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PerformanceCounterDescriptionKHR ) - offsetof( PerformanceCounterDescriptionKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + name = rhs.name; + category = rhs.category; + description = rhs.description; + return *this; } @@ -56258,7 +56855,12 @@ namespace VULKAN_HPP_NAMESPACE PerformanceCounterKHR & operator=( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PerformanceCounterKHR ) - offsetof( PerformanceCounterKHR, pNext ) ); + pNext = rhs.pNext; + unit = rhs.unit; + scope = rhs.scope; + storage = rhs.storage; + uuid = rhs.uuid; + return *this; } @@ -56409,8 +57011,9 @@ namespace VULKAN_HPP_NAMESPACE PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( PerformanceMarkerInfoINTEL ) - offsetof( PerformanceMarkerInfoINTEL, pNext ) ); + pNext = rhs.pNext; + marker = rhs.marker; + return *this; } @@ -56496,8 +57099,11 @@ namespace VULKAN_HPP_NAMESPACE PerformanceOverrideInfoINTEL & operator=( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( PerformanceOverrideInfoINTEL ) - offsetof( PerformanceOverrideInfoINTEL, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + enable = rhs.enable; + parameter = rhs.parameter; + return *this; } @@ -56594,9 +57200,9 @@ namespace VULKAN_HPP_NAMESPACE PerformanceQuerySubmitInfoKHR & operator=( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PerformanceQuerySubmitInfoKHR ) - offsetof( PerformanceQuerySubmitInfoKHR, pNext ) ); + pNext = rhs.pNext; + counterPassIndex = rhs.counterPassIndex; + return *this; } @@ -56676,9 +57282,9 @@ namespace VULKAN_HPP_NAMESPACE PerformanceStreamMarkerInfoINTEL & operator=( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PerformanceStreamMarkerInfoINTEL ) - offsetof( PerformanceStreamMarkerInfoINTEL, pNext ) ); + pNext = rhs.pNext; + marker = rhs.marker; + return *this; } @@ -56896,9 +57502,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevice16BitStorageFeatures & operator=( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevice16BitStorageFeatures ) - offsetof( PhysicalDevice16BitStorageFeatures, pNext ) ); + pNext = rhs.pNext; + storageBuffer16BitAccess = rhs.storageBuffer16BitAccess; + uniformAndStorageBuffer16BitAccess = rhs.uniformAndStorageBuffer16BitAccess; + storagePushConstant16 = rhs.storagePushConstant16; + storageInputOutput16 = rhs.storageInputOutput16; + return *this; } @@ -57013,9 +57622,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevice8BitStorageFeatures & operator=( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevice8BitStorageFeatures ) - offsetof( PhysicalDevice8BitStorageFeatures, pNext ) ); + pNext = rhs.pNext; + storageBuffer8BitAccess = rhs.storageBuffer8BitAccess; + uniformAndStorageBuffer8BitAccess = rhs.uniformAndStorageBuffer8BitAccess; + storagePushConstant8 = rhs.storagePushConstant8; + return *this; } @@ -57119,9 +57730,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceASTCDecodeFeaturesEXT & operator=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceASTCDecodeFeaturesEXT ) - offsetof( PhysicalDeviceASTCDecodeFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + decodeModeSharedExponent = rhs.decodeModeSharedExponent; + return *this; } @@ -57208,10 +57819,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) - - offsetof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + advancedBlendCoherentOperations = rhs.advancedBlendCoherentOperations; + return *this; } @@ -57310,10 +57920,14 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) - - offsetof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + advancedBlendMaxColorAttachments = rhs.advancedBlendMaxColorAttachments; + advancedBlendIndependentBlend = rhs.advancedBlendIndependentBlend; + advancedBlendNonPremultipliedSrcColor = rhs.advancedBlendNonPremultipliedSrcColor; + advancedBlendNonPremultipliedDstColor = rhs.advancedBlendNonPremultipliedDstColor; + advancedBlendCorrelatedOverlap = rhs.advancedBlendCorrelatedOverlap; + advancedBlendAllOperations = rhs.advancedBlendAllOperations; + return *this; } @@ -57402,10 +58016,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceBufferDeviceAddressFeatures & operator=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceBufferDeviceAddressFeatures ) - - offsetof( PhysicalDeviceBufferDeviceAddressFeatures, pNext ) ); + pNext = rhs.pNext; + bufferDeviceAddress = rhs.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = rhs.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = rhs.bufferDeviceAddressMultiDevice; + return *this; } @@ -57514,10 +58129,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceBufferDeviceAddressFeaturesEXT ) - - offsetof( PhysicalDeviceBufferDeviceAddressFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + bufferDeviceAddress = rhs.bufferDeviceAddress; + bufferDeviceAddressCaptureReplay = rhs.bufferDeviceAddressCaptureReplay; + bufferDeviceAddressMultiDevice = rhs.bufferDeviceAddressMultiDevice; + return *this; } @@ -57621,10 +58237,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCoherentMemoryFeaturesAMD ) - - offsetof( PhysicalDeviceCoherentMemoryFeaturesAMD, pNext ) ); + pNext = rhs.pNext; + deviceCoherentMemory = rhs.deviceCoherentMemory; + return *this; } @@ -57713,10 +58328,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceComputeShaderDerivativesFeaturesNV & operator=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceComputeShaderDerivativesFeaturesNV ) - - offsetof( PhysicalDeviceComputeShaderDerivativesFeaturesNV, pNext ) ); + pNext = rhs.pNext; + computeDerivativeGroupQuads = rhs.computeDerivativeGroupQuads; + computeDerivativeGroupLinear = rhs.computeDerivativeGroupLinear; + return *this; } @@ -57815,10 +58430,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceConditionalRenderingFeaturesEXT ) - - offsetof( PhysicalDeviceConditionalRenderingFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + conditionalRendering = rhs.conditionalRendering; + inheritedConditionalRendering = rhs.inheritedConditionalRendering; + return *this; } @@ -57931,10 +58546,17 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) - - offsetof( PhysicalDeviceConservativeRasterizationPropertiesEXT, pNext ) ); + 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; } @@ -58028,10 +58650,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCooperativeMatrixFeaturesNV ) - - offsetof( PhysicalDeviceCooperativeMatrixFeaturesNV, pNext ) ); + pNext = rhs.pNext; + cooperativeMatrix = rhs.cooperativeMatrix; + cooperativeMatrixRobustBufferAccess = rhs.cooperativeMatrixRobustBufferAccess; + return *this; } @@ -58127,10 +58749,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCooperativeMatrixPropertiesNV ) - - offsetof( PhysicalDeviceCooperativeMatrixPropertiesNV, pNext ) ); + pNext = rhs.pNext; + cooperativeMatrixSupportedStages = rhs.cooperativeMatrixSupportedStages; + return *this; } @@ -58205,10 +58826,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCornerSampledImageFeaturesNV & operator=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCornerSampledImageFeaturesNV ) - - offsetof( PhysicalDeviceCornerSampledImageFeaturesNV, pNext ) ); + pNext = rhs.pNext; + cornerSampledImage = rhs.cornerSampledImage; + return *this; } @@ -58295,10 +58915,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCoverageReductionModeFeaturesNV ) - - offsetof( PhysicalDeviceCoverageReductionModeFeaturesNV, pNext ) ); + pNext = rhs.pNext; + coverageReductionMode = rhs.coverageReductionMode; + return *this; } @@ -58387,10 +59006,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCustomBorderColorFeaturesEXT ) - - offsetof( PhysicalDeviceCustomBorderColorFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + customBorderColors = rhs.customBorderColors; + customBorderColorWithoutFormat = rhs.customBorderColorWithoutFormat; + return *this; } @@ -58486,10 +59105,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceCustomBorderColorPropertiesEXT ) - - offsetof( PhysicalDeviceCustomBorderColorPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + maxCustomBorderColorSamplers = rhs.maxCustomBorderColorSamplers; + return *this; } @@ -58565,10 +59183,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & operator=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) - - offsetof( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, pNext ) ); + pNext = rhs.pNext; + dedicatedAllocationImageAliasing = rhs.dedicatedAllocationImageAliasing; + return *this; } @@ -58657,10 +59274,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDepthClipEnableFeaturesEXT ) - - offsetof( PhysicalDeviceDepthClipEnableFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + depthClipEnable = rhs.depthClipEnable; + return *this; } @@ -58753,10 +59369,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDepthStencilResolveProperties & operator=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDepthStencilResolveProperties ) - - offsetof( PhysicalDeviceDepthStencilResolveProperties, pNext ) ); + pNext = rhs.pNext; + supportedDepthResolveModes = rhs.supportedDepthResolveModes; + supportedStencilResolveModes = rhs.supportedStencilResolveModes; + independentResolveNone = rhs.independentResolveNone; + independentResolve = rhs.independentResolve; + return *this; } @@ -58875,10 +59493,28 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDescriptorIndexingFeatures & operator=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDescriptorIndexingFeatures ) - - offsetof( PhysicalDeviceDescriptorIndexingFeatures, pNext ) ); + 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; } @@ -59185,10 +59821,31 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDescriptorIndexingProperties & operator=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDescriptorIndexingProperties ) - - offsetof( PhysicalDeviceDescriptorIndexingProperties, pNext ) ); + 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; } @@ -59319,10 +59976,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) - - offsetof( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, pNext ) ); + pNext = rhs.pNext; + deviceGeneratedCommands = rhs.deviceGeneratedCommands; + return *this; } @@ -59427,10 +60083,17 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) - - offsetof( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, pNext ) ); + 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; } @@ -59521,10 +60184,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDiagnosticsConfigFeaturesNV ) - - offsetof( PhysicalDeviceDiagnosticsConfigFeaturesNV, pNext ) ); + pNext = rhs.pNext; + diagnosticsConfig = rhs.diagnosticsConfig; + return *this; } @@ -59611,10 +60273,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) - - offsetof( PhysicalDeviceDiscardRectanglePropertiesEXT, pNext ) ); + pNext = rhs.pNext; + maxDiscardRectangles = rhs.maxDiscardRectangles; + return *this; } @@ -59690,9 +60351,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceDriverProperties ) - offsetof( PhysicalDeviceDriverProperties, pNext ) ); + pNext = rhs.pNext; + driverID = rhs.driverID; + driverName = rhs.driverName; + driverInfo = rhs.driverInfo; + conformanceVersion = rhs.conformanceVersion; + return *this; } @@ -59769,10 +60433,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExclusiveScissorFeaturesNV & operator=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExclusiveScissorFeaturesNV ) - - offsetof( PhysicalDeviceExclusiveScissorFeaturesNV, pNext ) ); + pNext = rhs.pNext; + exclusiveScissor = rhs.exclusiveScissor; + return *this; } @@ -59859,10 +60522,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExtendedDynamicStateFeaturesEXT ) - - offsetof( PhysicalDeviceExtendedDynamicStateFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + extendedDynamicState = rhs.extendedDynamicState; + return *this; } @@ -59950,9 +60612,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExternalBufferInfo & operator=( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExternalBufferInfo ) - offsetof( PhysicalDeviceExternalBufferInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + usage = rhs.usage; + handleType = rhs.handleType; + return *this; } @@ -60051,9 +60715,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExternalFenceInfo & operator=( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExternalFenceInfo ) - offsetof( PhysicalDeviceExternalFenceInfo, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + return *this; } @@ -60140,10 +60804,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExternalImageFormatInfo & operator=( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExternalImageFormatInfo ) - - offsetof( PhysicalDeviceExternalImageFormatInfo, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + return *this; } @@ -60230,10 +60893,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) - - offsetof( PhysicalDeviceExternalMemoryHostPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + minImportedHostPointerAlignment = rhs.minImportedHostPointerAlignment; + return *this; } @@ -60308,9 +60970,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceExternalSemaphoreInfo & operator=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceExternalSemaphoreInfo ) - offsetof( PhysicalDeviceExternalSemaphoreInfo, pNext ) ); + pNext = rhs.pNext; + handleType = rhs.handleType; + return *this; } @@ -60393,7 +61055,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFeatures2 & operator=( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceFeatures2 ) - offsetof( PhysicalDeviceFeatures2, pNext ) ); + pNext = rhs.pNext; + features = rhs.features; + return *this; } @@ -60511,10 +61175,25 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFloatControlsProperties & operator=( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFloatControlsProperties ) - - offsetof( PhysicalDeviceFloatControlsProperties, pNext ) ); + 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; } @@ -60622,10 +61301,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentDensityMap2FeaturesEXT ) - - offsetof( PhysicalDeviceFragmentDensityMap2FeaturesEXT, pNext ) ); + pNext = rhs.pNext; + fragmentDensityMapDeferred = rhs.fragmentDensityMapDeferred; + return *this; } @@ -60719,10 +61397,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentDensityMap2PropertiesEXT ) - - offsetof( PhysicalDeviceFragmentDensityMap2PropertiesEXT, pNext ) ); + pNext = rhs.pNext; + subsampledLoads = rhs.subsampledLoads; + subsampledCoarseReconstructionEarlyAccess = rhs.subsampledCoarseReconstructionEarlyAccess; + maxSubsampledArrayLayers = rhs.maxSubsampledArrayLayers; + maxDescriptorSetSubsampledSamplers = rhs.maxDescriptorSetSubsampledSamplers; + return *this; } @@ -60806,10 +61486,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentDensityMapFeaturesEXT ) - - offsetof( PhysicalDeviceFragmentDensityMapFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + fragmentDensityMap = rhs.fragmentDensityMap; + fragmentDensityMapDynamic = rhs.fragmentDensityMapDynamic; + fragmentDensityMapNonSubsampledImages = rhs.fragmentDensityMapNonSubsampledImages; + return *this; } @@ -60918,10 +61599,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentDensityMapPropertiesEXT ) - - offsetof( PhysicalDeviceFragmentDensityMapPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + minFragmentDensityTexelSize = rhs.minFragmentDensityTexelSize; + maxFragmentDensityTexelSize = rhs.maxFragmentDensityTexelSize; + fragmentDensityInvocations = rhs.fragmentDensityInvocations; + return *this; } @@ -61001,10 +61683,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentShaderBarycentricFeaturesNV & operator=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV ) - - offsetof( PhysicalDeviceFragmentShaderBarycentricFeaturesNV, pNext ) ); + pNext = rhs.pNext; + fragmentShaderBarycentric = rhs.fragmentShaderBarycentric; + return *this; } @@ -61096,10 +61777,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) - - offsetof( PhysicalDeviceFragmentShaderInterlockFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + fragmentShaderSampleInterlock = rhs.fragmentShaderSampleInterlock; + fragmentShaderPixelInterlock = rhs.fragmentShaderPixelInterlock; + fragmentShaderShadingRateInterlock = rhs.fragmentShaderShadingRateInterlock; + return *this; } @@ -61205,9 +61887,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceGroupProperties ) - offsetof( PhysicalDeviceGroupProperties, pNext ) ); + pNext = rhs.pNext; + physicalDeviceCount = rhs.physicalDeviceCount; + physicalDevices = rhs.physicalDevices; + subsetAllocation = rhs.subsetAllocation; + return *this; } @@ -61283,10 +61967,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceHostQueryResetFeatures & operator=( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceHostQueryResetFeatures ) - - offsetof( PhysicalDeviceHostQueryResetFeatures, pNext ) ); + pNext = rhs.pNext; + hostQueryReset = rhs.hostQueryReset; + return *this; } @@ -61376,8 +62059,13 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceIDProperties & operator=( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( PhysicalDeviceIDProperties ) - offsetof( PhysicalDeviceIDProperties, pNext ) ); + pNext = rhs.pNext; + deviceUUID = rhs.deviceUUID; + driverUUID = rhs.driverUUID; + deviceLUID = rhs.deviceLUID; + deviceNodeMask = rhs.deviceNodeMask; + deviceLUIDValid = rhs.deviceLUIDValid; + return *this; } @@ -61474,10 +62162,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceImageDrmFormatModifierInfoEXT ) - - offsetof( PhysicalDeviceImageDrmFormatModifierInfoEXT, pNext ) ); + pNext = rhs.pNext; + drmFormatModifier = rhs.drmFormatModifier; + sharingMode = rhs.sharingMode; + queueFamilyIndexCount = rhs.queueFamilyIndexCount; + pQueueFamilyIndices = rhs.pQueueFamilyIndices; + return *this; } @@ -61604,9 +62294,13 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceImageFormatInfo2 & operator=( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceImageFormatInfo2 ) - offsetof( PhysicalDeviceImageFormatInfo2, pNext ) ); + pNext = rhs.pNext; + format = rhs.format; + type = rhs.type; + tiling = rhs.tiling; + usage = rhs.usage; + flags = rhs.flags; + return *this; } @@ -61721,10 +62415,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceImageViewImageFormatInfoEXT & operator=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceImageViewImageFormatInfoEXT ) - - offsetof( PhysicalDeviceImageViewImageFormatInfoEXT, pNext ) ); + pNext = rhs.pNext; + imageViewType = rhs.imageViewType; + return *this; } @@ -61811,10 +62504,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceImagelessFramebufferFeatures & operator=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceImagelessFramebufferFeatures ) - - offsetof( PhysicalDeviceImagelessFramebufferFeatures, pNext ) ); + pNext = rhs.pNext; + imagelessFramebuffer = rhs.imagelessFramebuffer; + return *this; } @@ -61900,10 +62592,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceIndexTypeUint8FeaturesEXT & operator=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceIndexTypeUint8FeaturesEXT ) - - offsetof( PhysicalDeviceIndexTypeUint8FeaturesEXT, pNext ) ); + pNext = rhs.pNext; + indexTypeUint8 = rhs.indexTypeUint8; + return *this; } @@ -61992,10 +62683,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceInlineUniformBlockFeaturesEXT & operator=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceInlineUniformBlockFeaturesEXT ) - - offsetof( PhysicalDeviceInlineUniformBlockFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + inlineUniformBlock = rhs.inlineUniformBlock; + descriptorBindingInlineUniformBlockUpdateAfterBind = rhs.descriptorBindingInlineUniformBlockUpdateAfterBind; + return *this; } @@ -62101,10 +62792,14 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceInlineUniformBlockPropertiesEXT & operator=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceInlineUniformBlockPropertiesEXT ) - - offsetof( PhysicalDeviceInlineUniformBlockPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + maxInlineUniformBlockSize = rhs.maxInlineUniformBlockSize; + maxPerStageDescriptorInlineUniformBlocks = rhs.maxPerStageDescriptorInlineUniformBlocks; + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = + rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + maxDescriptorSetInlineUniformBlocks = rhs.maxDescriptorSetInlineUniformBlocks; + maxDescriptorSetUpdateAfterBindInlineUniformBlocks = rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + return *this; } @@ -62663,10 +63358,14 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceLineRasterizationFeaturesEXT & operator=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceLineRasterizationFeaturesEXT ) - - offsetof( PhysicalDeviceLineRasterizationFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + rectangularLines = rhs.rectangularLines; + bresenhamLines = rhs.bresenhamLines; + smoothLines = rhs.smoothLines; + stippledRectangularLines = rhs.stippledRectangularLines; + stippledBresenhamLines = rhs.stippledBresenhamLines; + stippledSmoothLines = rhs.stippledSmoothLines; + return *this; } @@ -62797,10 +63496,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceLineRasterizationPropertiesEXT & operator=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceLineRasterizationPropertiesEXT ) - - offsetof( PhysicalDeviceLineRasterizationPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + lineSubPixelPrecisionBits = rhs.lineSubPixelPrecisionBits; + return *this; } @@ -62876,10 +63574,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMaintenance3Properties & operator=( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMaintenance3Properties ) - - offsetof( PhysicalDeviceMaintenance3Properties, pNext ) ); + pNext = rhs.pNext; + maxPerSetDescriptors = rhs.maxPerSetDescriptors; + maxMemoryAllocationSize = rhs.maxMemoryAllocationSize; + return *this; } @@ -62955,10 +63653,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMemoryBudgetPropertiesEXT ) - - offsetof( PhysicalDeviceMemoryBudgetPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + heapBudget = rhs.heapBudget; + heapUsage = rhs.heapUsage; + return *this; } @@ -63033,10 +63731,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMemoryPriorityFeaturesEXT ) - - offsetof( PhysicalDeviceMemoryPriorityFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + memoryPriority = rhs.memoryPriority; + return *this; } @@ -63181,9 +63878,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMemoryProperties2 & operator=( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMemoryProperties2 ) - offsetof( PhysicalDeviceMemoryProperties2, pNext ) ); + pNext = rhs.pNext; + memoryProperties = rhs.memoryProperties; + return *this; } @@ -63256,9 +63953,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMeshShaderFeaturesNV & operator=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMeshShaderFeaturesNV ) - offsetof( PhysicalDeviceMeshShaderFeaturesNV, pNext ) ); + pNext = rhs.pNext; + taskShader = rhs.taskShader; + meshShader = rhs.meshShader; + return *this; } @@ -63374,10 +64072,21 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMeshShaderPropertiesNV & operator=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMeshShaderPropertiesNV ) - - offsetof( PhysicalDeviceMeshShaderPropertiesNV, pNext ) ); + 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; } @@ -63475,9 +64184,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMultiviewFeatures & operator=( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMultiviewFeatures ) - offsetof( PhysicalDeviceMultiviewFeatures, pNext ) ); + pNext = rhs.pNext; + multiview = rhs.multiview; + multiviewGeometryShader = rhs.multiviewGeometryShader; + multiviewTessellationShader = rhs.multiviewTessellationShader; + return *this; } @@ -63581,10 +64292,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) - - offsetof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, pNext ) ); + pNext = rhs.pNext; + perViewPositionAllComponents = rhs.perViewPositionAllComponents; + return *this; } @@ -63659,9 +64369,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceMultiviewProperties & operator=( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceMultiviewProperties ) - offsetof( PhysicalDeviceMultiviewProperties, pNext ) ); + pNext = rhs.pNext; + maxMultiviewViewCount = rhs.maxMultiviewViewCount; + maxMultiviewInstanceIndex = rhs.maxMultiviewInstanceIndex; + return *this; } @@ -63741,10 +64452,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePCIBusInfoPropertiesEXT & operator=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePCIBusInfoPropertiesEXT ) - - offsetof( PhysicalDevicePCIBusInfoPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + pciDomain = rhs.pciDomain; + pciBus = rhs.pciBus; + pciDevice = rhs.pciDevice; + pciFunction = rhs.pciFunction; + return *this; } @@ -63823,10 +64536,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePerformanceQueryFeaturesKHR & operator=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePerformanceQueryFeaturesKHR ) - - offsetof( PhysicalDevicePerformanceQueryFeaturesKHR, pNext ) ); + pNext = rhs.pNext; + performanceCounterQueryPools = rhs.performanceCounterQueryPools; + performanceCounterMultipleQueryPools = rhs.performanceCounterMultipleQueryPools; + return *this; } @@ -63923,10 +64636,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePerformanceQueryPropertiesKHR & operator=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePerformanceQueryPropertiesKHR ) - - offsetof( PhysicalDevicePerformanceQueryPropertiesKHR, pNext ) ); + pNext = rhs.pNext; + allowCommandBufferQueryCopies = rhs.allowCommandBufferQueryCopies; + return *this; } @@ -64002,10 +64714,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePipelineCreationCacheControlFeaturesEXT & operator=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT ) - - offsetof( PhysicalDevicePipelineCreationCacheControlFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + pipelineCreationCacheControl = rhs.pipelineCreationCacheControl; + return *this; } @@ -64095,10 +64806,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) - - offsetof( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, pNext ) ); + pNext = rhs.pNext; + pipelineExecutableInfo = rhs.pipelineExecutableInfo; + return *this; } @@ -64187,10 +64897,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePointClippingProperties & operator=( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePointClippingProperties ) - - offsetof( PhysicalDevicePointClippingProperties, pNext ) ); + pNext = rhs.pNext; + pointClippingBehavior = rhs.pointClippingBehavior; + return *this; } @@ -64263,10 +64972,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePrivateDataFeaturesEXT & operator=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePrivateDataFeaturesEXT ) - - offsetof( PhysicalDevicePrivateDataFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + privateData = rhs.privateData; + return *this; } @@ -64494,7 +65202,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceProperties2 & operator=( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PhysicalDeviceProperties2 ) - offsetof( PhysicalDeviceProperties2, pNext ) ); + pNext = rhs.pNext; + properties = rhs.properties; + return *this; } @@ -64566,10 +65276,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceProtectedMemoryFeatures & operator=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceProtectedMemoryFeatures ) - - offsetof( PhysicalDeviceProtectedMemoryFeatures, pNext ) ); + pNext = rhs.pNext; + protectedMemory = rhs.protectedMemory; + return *this; } @@ -64654,10 +65363,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceProtectedMemoryProperties & operator=( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceProtectedMemoryProperties ) - - offsetof( PhysicalDeviceProtectedMemoryProperties, pNext ) ); + pNext = rhs.pNext; + protectedNoFault = rhs.protectedNoFault; + return *this; } @@ -64731,10 +65439,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDevicePushDescriptorPropertiesKHR & operator=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) - - offsetof( PhysicalDevicePushDescriptorPropertiesKHR, pNext ) ); + pNext = rhs.pNext; + maxPushDescriptors = rhs.maxPushDescriptors; + return *this; } @@ -64824,9 +65531,17 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRayTracingFeaturesKHR & operator=( PhysicalDeviceRayTracingFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRayTracingFeaturesKHR ) - offsetof( PhysicalDeviceRayTracingFeaturesKHR, pNext ) ); + pNext = rhs.pNext; + rayTracing = rhs.rayTracing; + rayTracingShaderGroupHandleCaptureReplay = rhs.rayTracingShaderGroupHandleCaptureReplay; + rayTracingShaderGroupHandleCaptureReplayMixed = rhs.rayTracingShaderGroupHandleCaptureReplayMixed; + rayTracingAccelerationStructureCaptureReplay = rhs.rayTracingAccelerationStructureCaptureReplay; + rayTracingIndirectTraceRays = rhs.rayTracingIndirectTraceRays; + rayTracingIndirectAccelerationStructureBuild = rhs.rayTracingIndirectAccelerationStructureBuild; + rayTracingHostAccelerationStructureCommands = rhs.rayTracingHostAccelerationStructureCommands; + rayQuery = rhs.rayQuery; + rayTracingPrimitiveCulling = rhs.rayTracingPrimitiveCulling; + return *this; } @@ -64998,10 +65713,17 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRayTracingPropertiesKHR & operator=( PhysicalDeviceRayTracingPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRayTracingPropertiesKHR ) - - offsetof( PhysicalDeviceRayTracingPropertiesKHR, pNext ) ); + pNext = rhs.pNext; + shaderGroupHandleSize = rhs.shaderGroupHandleSize; + maxRecursionDepth = rhs.maxRecursionDepth; + maxShaderGroupStride = rhs.maxShaderGroupStride; + shaderGroupBaseAlignment = rhs.shaderGroupBaseAlignment; + maxGeometryCount = rhs.maxGeometryCount; + maxInstanceCount = rhs.maxInstanceCount; + maxPrimitiveCount = rhs.maxPrimitiveCount; + maxDescriptorSetAccelerationStructures = rhs.maxDescriptorSetAccelerationStructures; + shaderGroupHandleCaptureReplaySize = rhs.shaderGroupHandleCaptureReplaySize; + return *this; } @@ -65103,10 +65825,16 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRayTracingPropertiesNV & operator=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRayTracingPropertiesNV ) - - offsetof( PhysicalDeviceRayTracingPropertiesNV, pNext ) ); + 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; } @@ -65193,10 +65921,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) - - offsetof( PhysicalDeviceRepresentativeFragmentTestFeaturesNV, pNext ) ); + pNext = rhs.pNext; + representativeFragmentTest = rhs.representativeFragmentTest; + return *this; } @@ -65288,10 +66015,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRobustness2FeaturesEXT & operator=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRobustness2FeaturesEXT ) - - offsetof( PhysicalDeviceRobustness2FeaturesEXT, pNext ) ); + pNext = rhs.pNext; + robustBufferAccess2 = rhs.robustBufferAccess2; + robustImageAccess2 = rhs.robustImageAccess2; + nullDescriptor = rhs.nullDescriptor; + return *this; } @@ -65395,10 +66123,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceRobustness2PropertiesEXT & operator=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceRobustness2PropertiesEXT ) - - offsetof( PhysicalDeviceRobustness2PropertiesEXT, pNext ) ); + pNext = rhs.pNext; + robustStorageBufferAccessSizeAlignment = rhs.robustStorageBufferAccessSizeAlignment; + robustUniformBufferAccessSizeAlignment = rhs.robustUniformBufferAccessSizeAlignment; + return *this; } @@ -65482,10 +66210,13 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSampleLocationsPropertiesEXT & operator=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) - - offsetof( PhysicalDeviceSampleLocationsPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + sampleLocationSampleCounts = rhs.sampleLocationSampleCounts; + maxSampleLocationGridSize = rhs.maxSampleLocationGridSize; + sampleLocationCoordinateRange = rhs.sampleLocationCoordinateRange; + sampleLocationSubPixelBits = rhs.sampleLocationSubPixelBits; + variableSampleLocations = rhs.variableSampleLocations; + return *this; } @@ -65570,10 +66301,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSamplerFilterMinmaxProperties & operator=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSamplerFilterMinmaxProperties ) - - offsetof( PhysicalDeviceSamplerFilterMinmaxProperties, pNext ) ); + pNext = rhs.pNext; + filterMinmaxSingleComponentFormats = rhs.filterMinmaxSingleComponentFormats; + filterMinmaxImageComponentMapping = rhs.filterMinmaxImageComponentMapping; + return *this; } @@ -65650,10 +66381,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSamplerYcbcrConversionFeatures ) - - offsetof( PhysicalDeviceSamplerYcbcrConversionFeatures, pNext ) ); + pNext = rhs.pNext; + samplerYcbcrConversion = rhs.samplerYcbcrConversion; + return *this; } @@ -65739,10 +66469,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceScalarBlockLayoutFeatures & operator=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceScalarBlockLayoutFeatures ) - - offsetof( PhysicalDeviceScalarBlockLayoutFeatures, pNext ) ); + pNext = rhs.pNext; + scalarBlockLayout = rhs.scalarBlockLayout; + return *this; } @@ -65830,10 +66559,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSeparateDepthStencilLayoutsFeatures & operator=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) - - offsetof( PhysicalDeviceSeparateDepthStencilLayoutsFeatures, pNext ) ); + pNext = rhs.pNext; + separateDepthStencilLayouts = rhs.separateDepthStencilLayouts; + return *this; } @@ -65922,10 +66650,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderAtomicInt64Features & operator=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderAtomicInt64Features ) - - offsetof( PhysicalDeviceShaderAtomicInt64Features, pNext ) ); + pNext = rhs.pNext; + shaderBufferInt64Atomics = rhs.shaderBufferInt64Atomics; + shaderSharedInt64Atomics = rhs.shaderSharedInt64Atomics; + return *this; } @@ -66023,10 +66751,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderClockFeaturesKHR & operator=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderClockFeaturesKHR ) - - offsetof( PhysicalDeviceShaderClockFeaturesKHR, pNext ) ); + pNext = rhs.pNext; + shaderSubgroupClock = rhs.shaderSubgroupClock; + shaderDeviceClock = rhs.shaderDeviceClock; + return *this; } @@ -66122,10 +66850,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderCoreProperties2AMD & operator=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderCoreProperties2AMD ) - - offsetof( PhysicalDeviceShaderCoreProperties2AMD, pNext ) ); + pNext = rhs.pNext; + shaderCoreFeatures = rhs.shaderCoreFeatures; + activeComputeUnitCount = rhs.activeComputeUnitCount; + return *this; } @@ -66225,10 +66953,22 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderCorePropertiesAMD & operator=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderCorePropertiesAMD ) - - offsetof( PhysicalDeviceShaderCorePropertiesAMD, pNext ) ); + 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; } @@ -66323,10 +67063,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT & operator=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT ) - - offsetof( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + shaderDemoteToHelperInvocation = rhs.shaderDemoteToHelperInvocation; + return *this; } @@ -66415,10 +67154,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderDrawParametersFeatures & operator=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderDrawParametersFeatures ) - - offsetof( PhysicalDeviceShaderDrawParametersFeatures, pNext ) ); + pNext = rhs.pNext; + shaderDrawParameters = rhs.shaderDrawParameters; + return *this; } @@ -66506,10 +67244,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderFloat16Int8Features & operator=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderFloat16Int8Features ) - - offsetof( PhysicalDeviceShaderFloat16Int8Features, pNext ) ); + pNext = rhs.pNext; + shaderFloat16 = rhs.shaderFloat16; + shaderInt8 = rhs.shaderInt8; + return *this; } @@ -66604,10 +67342,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderImageFootprintFeaturesNV ) - - offsetof( PhysicalDeviceShaderImageFootprintFeaturesNV, pNext ) ); + pNext = rhs.pNext; + imageFootprint = rhs.imageFootprint; + return *this; } @@ -66695,10 +67432,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) - - offsetof( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, pNext ) ); + pNext = rhs.pNext; + shaderIntegerFunctions2 = rhs.shaderIntegerFunctions2; + return *this; } @@ -66786,10 +67522,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderSMBuiltinsFeaturesNV ) - - offsetof( PhysicalDeviceShaderSMBuiltinsFeaturesNV, pNext ) ); + pNext = rhs.pNext; + shaderSMBuiltins = rhs.shaderSMBuiltins; + return *this; } @@ -66878,10 +67613,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderSMBuiltinsPropertiesNV ) - - offsetof( PhysicalDeviceShaderSMBuiltinsPropertiesNV, pNext ) ); + pNext = rhs.pNext; + shaderSMCount = rhs.shaderSMCount; + shaderWarpsPerSM = rhs.shaderWarpsPerSM; + return *this; } @@ -66958,10 +67693,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShaderSubgroupExtendedTypesFeatures & operator=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) - - offsetof( PhysicalDeviceShaderSubgroupExtendedTypesFeatures, pNext ) ); + pNext = rhs.pNext; + shaderSubgroupExtendedTypes = rhs.shaderSubgroupExtendedTypes; + return *this; } @@ -67051,10 +67785,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShadingRateImageFeaturesNV & operator=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShadingRateImageFeaturesNV ) - - offsetof( PhysicalDeviceShadingRateImageFeaturesNV, pNext ) ); + pNext = rhs.pNext; + shadingRateImage = rhs.shadingRateImage; + shadingRateCoarseSampleOrder = rhs.shadingRateCoarseSampleOrder; + return *this; } @@ -67154,10 +67888,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceShadingRateImagePropertiesNV & operator=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceShadingRateImagePropertiesNV ) - - offsetof( PhysicalDeviceShadingRateImagePropertiesNV, pNext ) ); + pNext = rhs.pNext; + shadingRateTexelSize = rhs.shadingRateTexelSize; + shadingRatePaletteSize = rhs.shadingRatePaletteSize; + shadingRateMaxCoarseSamples = rhs.shadingRateMaxCoarseSamples; + return *this; } @@ -67242,10 +67977,13 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSparseImageFormatInfo2 & operator=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSparseImageFormatInfo2 ) - - offsetof( PhysicalDeviceSparseImageFormatInfo2, pNext ) ); + pNext = rhs.pNext; + format = rhs.format; + type = rhs.type; + samples = rhs.samples; + usage = rhs.usage; + tiling = rhs.tiling; + return *this; } @@ -67362,9 +68100,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSubgroupProperties & operator=( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSubgroupProperties ) - offsetof( PhysicalDeviceSubgroupProperties, pNext ) ); + pNext = rhs.pNext; + subgroupSize = rhs.subgroupSize; + supportedStages = rhs.supportedStages; + supportedOperations = rhs.supportedOperations; + quadOperationsInAllStages = rhs.quadOperationsInAllStages; + return *this; } @@ -67444,10 +68185,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSubgroupSizeControlFeaturesEXT & operator=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSubgroupSizeControlFeaturesEXT ) - - offsetof( PhysicalDeviceSubgroupSizeControlFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + subgroupSizeControl = rhs.subgroupSizeControl; + computeFullSubgroups = rhs.computeFullSubgroups; + return *this; } @@ -67549,10 +68290,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSubgroupSizeControlPropertiesEXT & operator=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSubgroupSizeControlPropertiesEXT ) - - offsetof( PhysicalDeviceSubgroupSizeControlPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + minSubgroupSize = rhs.minSubgroupSize; + maxSubgroupSize = rhs.maxSubgroupSize; + maxComputeWorkgroupSubgroups = rhs.maxComputeWorkgroupSubgroups; + requiredSubgroupSizeStages = rhs.requiredSubgroupSizeStages; + return *this; } @@ -67628,9 +68371,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceSurfaceInfo2KHR & operator=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceSurfaceInfo2KHR ) - offsetof( PhysicalDeviceSurfaceInfo2KHR, pNext ) ); + pNext = rhs.pNext; + surface = rhs.surface; + return *this; } @@ -67715,10 +68458,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) - - offsetof( PhysicalDeviceTexelBufferAlignmentFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + texelBufferAlignment = rhs.texelBufferAlignment; + return *this; } @@ -67811,10 +68553,12 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTexelBufferAlignmentPropertiesEXT & operator=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT ) - - offsetof( PhysicalDeviceTexelBufferAlignmentPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + storageTexelBufferOffsetAlignmentBytes = rhs.storageTexelBufferOffsetAlignmentBytes; + storageTexelBufferOffsetSingleTexelAlignment = rhs.storageTexelBufferOffsetSingleTexelAlignment; + uniformTexelBufferOffsetAlignmentBytes = rhs.uniformTexelBufferOffsetAlignmentBytes; + uniformTexelBufferOffsetSingleTexelAlignment = rhs.uniformTexelBufferOffsetSingleTexelAlignment; + return *this; } @@ -67896,10 +68640,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT & operator=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT ) - - offsetof( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + textureCompressionASTC_HDR = rhs.textureCompressionASTC_HDR; + return *this; } @@ -67986,10 +68729,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTimelineSemaphoreFeatures & operator=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTimelineSemaphoreFeatures ) - - offsetof( PhysicalDeviceTimelineSemaphoreFeatures, pNext ) ); + pNext = rhs.pNext; + timelineSemaphore = rhs.timelineSemaphore; + return *this; } @@ -68075,10 +68817,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTimelineSemaphoreProperties & operator=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTimelineSemaphoreProperties ) - - offsetof( PhysicalDeviceTimelineSemaphoreProperties, pNext ) ); + pNext = rhs.pNext; + maxTimelineSemaphoreValueDifference = rhs.maxTimelineSemaphoreValueDifference; + return *this; } @@ -68157,9 +68898,13 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceToolPropertiesEXT & operator=( PhysicalDeviceToolPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceToolPropertiesEXT ) - offsetof( PhysicalDeviceToolPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + name = rhs.name; + version = rhs.version; + purposes = rhs.purposes; + description = rhs.description; + layer = rhs.layer; + return *this; } @@ -68239,10 +68984,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTransformFeedbackFeaturesEXT ) - - offsetof( PhysicalDeviceTransformFeedbackFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + transformFeedback = rhs.transformFeedback; + geometryStreams = rhs.geometryStreams; + return *this; } @@ -68356,10 +69101,18 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceTransformFeedbackPropertiesEXT ) - - offsetof( PhysicalDeviceTransformFeedbackPropertiesEXT, pNext ) ); + 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; } @@ -68453,10 +69206,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceUniformBufferStandardLayoutFeatures & operator=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceUniformBufferStandardLayoutFeatures ) - - offsetof( PhysicalDeviceUniformBufferStandardLayoutFeatures, pNext ) ); + pNext = rhs.pNext; + uniformBufferStandardLayout = rhs.uniformBufferStandardLayout; + return *this; } @@ -68545,10 +69297,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVariablePointersFeatures & operator=( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVariablePointersFeatures ) - - offsetof( PhysicalDeviceVariablePointersFeatures, pNext ) ); + pNext = rhs.pNext; + variablePointersStorageBuffer = rhs.variablePointersStorageBuffer; + variablePointers = rhs.variablePointers; + return *this; } @@ -68646,10 +69398,10 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVertexAttributeDivisorFeaturesEXT & operator=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT ) - - offsetof( PhysicalDeviceVertexAttributeDivisorFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + vertexAttributeInstanceRateDivisor = rhs.vertexAttributeInstanceRateDivisor; + vertexAttributeInstanceRateZeroDivisor = rhs.vertexAttributeInstanceRateZeroDivisor; + return *this; } @@ -68747,10 +69499,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) - - offsetof( PhysicalDeviceVertexAttributeDivisorPropertiesEXT, pNext ) ); + pNext = rhs.pNext; + maxVertexAttribDivisor = rhs.maxVertexAttribDivisor; + return *this; } @@ -68843,9 +69594,20 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVulkan11Features & operator=( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVulkan11Features ) - offsetof( PhysicalDeviceVulkan11Features, pNext ) ); + 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; } @@ -69053,9 +69815,23 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVulkan11Properties & operator=( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVulkan11Properties ) - offsetof( PhysicalDeviceVulkan11Properties, pNext ) ); + 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; } @@ -69241,9 +70017,55 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVulkan12Features & operator=( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVulkan12Features ) - offsetof( PhysicalDeviceVulkan12Features, pNext ) ); + 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; } @@ -69842,9 +70664,60 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVulkan12Properties ) - offsetof( PhysicalDeviceVulkan12Properties, pNext ) ); + 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; } @@ -70036,10 +70909,11 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceVulkanMemoryModelFeatures & operator=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceVulkanMemoryModelFeatures ) - - offsetof( PhysicalDeviceVulkanMemoryModelFeatures, pNext ) ); + pNext = rhs.pNext; + vulkanMemoryModel = rhs.vulkanMemoryModel; + vulkanMemoryModelDeviceScope = rhs.vulkanMemoryModelDeviceScope; + vulkanMemoryModelAvailabilityVisibilityChains = rhs.vulkanMemoryModelAvailabilityVisibilityChains; + return *this; } @@ -70143,10 +71017,9 @@ namespace VULKAN_HPP_NAMESPACE PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PhysicalDeviceYcbcrImageArraysFeaturesEXT ) - - offsetof( PhysicalDeviceYcbcrImageArraysFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + ycbcrImageArrays = rhs.ycbcrImageArrays; + return *this; } @@ -70240,7 +71113,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineCacheCreateInfo & operator=( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PipelineCacheCreateInfo ) - offsetof( PipelineCacheCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + initialDataSize = rhs.initialDataSize; + pInitialData = rhs.pInitialData; + return *this; } @@ -70355,10 +71232,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) - - offsetof( PipelineColorBlendAdvancedStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + srcPremultiplied = rhs.srcPremultiplied; + dstPremultiplied = rhs.dstPremultiplied; + blendOverlap = rhs.blendOverlap; + return *this; } @@ -70461,10 +71339,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineCompilerControlCreateInfoAMD & operator=( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineCompilerControlCreateInfoAMD ) - - offsetof( PipelineCompilerControlCreateInfoAMD, pNext ) ); + pNext = rhs.pNext; + compilerControlFlags = rhs.compilerControlFlags; + return *this; } @@ -70573,10 +71450,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineCoverageModulationStateCreateInfoNV & operator=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineCoverageModulationStateCreateInfoNV ) - - offsetof( PipelineCoverageModulationStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + coverageModulationMode = rhs.coverageModulationMode; + coverageModulationTableEnable = rhs.coverageModulationTableEnable; + coverageModulationTableCount = rhs.coverageModulationTableCount; + pCoverageModulationTable = rhs.pCoverageModulationTable; + return *this; } @@ -70713,10 +71593,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineCoverageReductionStateCreateInfoNV & operator=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineCoverageReductionStateCreateInfoNV ) - - offsetof( PipelineCoverageReductionStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + coverageReductionMode = rhs.coverageReductionMode; + return *this; } @@ -70817,10 +71697,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineCoverageToColorStateCreateInfoNV & operator=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineCoverageToColorStateCreateInfoNV ) - - offsetof( PipelineCoverageToColorStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + coverageToColorEnable = rhs.coverageToColorEnable; + coverageToColorLocation = rhs.coverageToColorLocation; + return *this; } @@ -70994,10 +71875,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineCreationFeedbackCreateInfoEXT & operator=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineCreationFeedbackCreateInfoEXT ) - - offsetof( PipelineCreationFeedbackCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + pPipelineCreationFeedback = rhs.pPipelineCreationFeedback; + pipelineStageCreationFeedbackCount = rhs.pipelineStageCreationFeedbackCount; + pPipelineStageCreationFeedbacks = rhs.pPipelineStageCreationFeedbacks; + return *this; } @@ -71132,10 +72014,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineDiscardRectangleStateCreateInfoEXT & operator=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) - - offsetof( PipelineDiscardRectangleStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + discardRectangleMode = rhs.discardRectangleMode; + discardRectangleCount = rhs.discardRectangleCount; + pDiscardRectangles = rhs.pDiscardRectangles; + return *this; } @@ -71257,7 +72141,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineExecutableInfoKHR & operator=( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PipelineExecutableInfoKHR ) - offsetof( PipelineExecutableInfoKHR, pNext ) ); + pNext = rhs.pNext; + pipeline = rhs.pipeline; + executableIndex = rhs.executableIndex; + return *this; } @@ -71372,10 +72259,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineExecutableInternalRepresentationKHR & operator=( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineExecutableInternalRepresentationKHR ) - - offsetof( PipelineExecutableInternalRepresentationKHR, pNext ) ); + pNext = rhs.pNext; + name = rhs.name; + description = rhs.description; + isText = rhs.isText; + dataSize = rhs.dataSize; + pData = rhs.pData; + return *this; } @@ -71457,9 +72347,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineExecutablePropertiesKHR ) - offsetof( PipelineExecutablePropertiesKHR, pNext ) ); + pNext = rhs.pNext; + stages = rhs.stages; + name = rhs.name; + description = rhs.description; + subgroupSize = rhs.subgroupSize; + return *this; } @@ -71609,9 +72502,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineExecutableStatisticKHR ) - offsetof( PipelineExecutableStatisticKHR, pNext ) ); + pNext = rhs.pNext; + name = rhs.name; + description = rhs.description; + format = rhs.format; + value = rhs.value; + return *this; } @@ -71669,7 +72565,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineInfoKHR & operator=( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PipelineInfoKHR ) - offsetof( PipelineInfoKHR, pNext ) ); + pNext = rhs.pNext; + pipeline = rhs.pipeline; + return *this; } @@ -71845,7 +72743,13 @@ namespace VULKAN_HPP_NAMESPACE PipelineLayoutCreateInfo & operator=( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PipelineLayoutCreateInfo ) - offsetof( PipelineLayoutCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + setLayoutCount = rhs.setLayoutCount; + pSetLayouts = rhs.pSetLayouts; + pushConstantRangeCount = rhs.pushConstantRangeCount; + pPushConstantRanges = rhs.pPushConstantRanges; + return *this; } @@ -71990,8 +72894,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineLibraryCreateInfoKHR & operator=( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( PipelineLibraryCreateInfoKHR ) - offsetof( PipelineLibraryCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + libraryCount = rhs.libraryCount; + pLibraries = rhs.pLibraries; + return *this; } @@ -72103,10 +73009,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationConservativeStateCreateInfoEXT & operator=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) - - offsetof( PipelineRasterizationConservativeStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + conservativeRasterizationMode = rhs.conservativeRasterizationMode; + extraPrimitiveOverestimationSize = rhs.extraPrimitiveOverestimationSize; + return *this; } @@ -72215,10 +73122,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationDepthClipStateCreateInfoEXT ) - - offsetof( PipelineRasterizationDepthClipStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + depthClipEnable = rhs.depthClipEnable; + return *this; } @@ -72321,10 +73228,12 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationLineStateCreateInfoEXT & operator=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationLineStateCreateInfoEXT ) - - offsetof( PipelineRasterizationLineStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + lineRasterizationMode = rhs.lineRasterizationMode; + stippledLineEnable = rhs.stippledLineEnable; + lineStippleFactor = rhs.lineStippleFactor; + lineStipplePattern = rhs.lineStipplePattern; + return *this; } @@ -72440,10 +73349,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationStateRasterizationOrderAMD & operator=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationStateRasterizationOrderAMD ) - - offsetof( PipelineRasterizationStateRasterizationOrderAMD, pNext ) ); + pNext = rhs.pNext; + rasterizationOrder = rhs.rasterizationOrder; + return *this; } @@ -72533,10 +73441,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineRasterizationStateStreamCreateInfoEXT & operator=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRasterizationStateStreamCreateInfoEXT ) - - offsetof( PipelineRasterizationStateStreamCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + rasterizationStream = rhs.rasterizationStream; + return *this; } @@ -72633,10 +73541,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineRepresentativeFragmentTestStateCreateInfoNV ) - - offsetof( PipelineRepresentativeFragmentTestStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + representativeFragmentTestEnable = rhs.representativeFragmentTestEnable; + return *this; } @@ -72727,10 +73634,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineSampleLocationsStateCreateInfoEXT & operator=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineSampleLocationsStateCreateInfoEXT ) - - offsetof( PipelineSampleLocationsStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + sampleLocationsEnable = rhs.sampleLocationsEnable; + sampleLocationsInfo = rhs.sampleLocationsInfo; + return *this; } @@ -72828,10 +73735,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT & operator=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT ) - - offsetof( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + requiredSubgroupSize = rhs.requiredSubgroupSize; + return *this; } @@ -72906,10 +73812,9 @@ namespace VULKAN_HPP_NAMESPACE PipelineTessellationDomainOriginStateCreateInfo & operator=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineTessellationDomainOriginStateCreateInfo ) - - offsetof( PipelineTessellationDomainOriginStateCreateInfo, pNext ) ); + pNext = rhs.pNext; + domainOrigin = rhs.domainOrigin; + return *this; } @@ -73077,10 +73982,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineVertexInputDivisorStateCreateInfoEXT & operator=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineVertexInputDivisorStateCreateInfoEXT ) - - offsetof( PipelineVertexInputDivisorStateCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + vertexBindingDivisorCount = rhs.vertexBindingDivisorCount; + pVertexBindingDivisors = rhs.pVertexBindingDivisors; + return *this; } @@ -73207,10 +74112,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportCoarseSampleOrderStateCreateInfoNV ) - - offsetof( PipelineViewportCoarseSampleOrderStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + sampleOrderType = rhs.sampleOrderType; + customSampleOrderCount = rhs.customSampleOrderCount; + pCustomSampleOrders = rhs.pCustomSampleOrders; + return *this; } @@ -73339,10 +74245,10 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportExclusiveScissorStateCreateInfoNV ) - - offsetof( PipelineViewportExclusiveScissorStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + exclusiveScissorCount = rhs.exclusiveScissorCount; + pExclusiveScissors = rhs.pExclusiveScissors; + return *this; } @@ -73553,10 +74459,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportShadingRateImageStateCreateInfoNV & operator=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportShadingRateImageStateCreateInfoNV ) - - offsetof( PipelineViewportShadingRateImageStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + shadingRateImageEnable = rhs.shadingRateImageEnable; + viewportCount = rhs.viewportCount; + pShadingRatePalettes = rhs.pShadingRatePalettes; + return *this; } @@ -73774,10 +74681,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportSwizzleStateCreateInfoNV & operator=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportSwizzleStateCreateInfoNV ) - - offsetof( PipelineViewportSwizzleStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + viewportCount = rhs.viewportCount; + pViewportSwizzles = rhs.pViewportSwizzles; + return *this; } @@ -73970,10 +74878,11 @@ namespace VULKAN_HPP_NAMESPACE PipelineViewportWScalingStateCreateInfoNV & operator=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( PipelineViewportWScalingStateCreateInfoNV ) - - offsetof( PipelineViewportWScalingStateCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + viewportWScalingEnable = rhs.viewportWScalingEnable; + viewportCount = rhs.viewportCount; + pViewportWScalings = rhs.pViewportWScalings; + return *this; } @@ -74084,7 +74993,9 @@ namespace VULKAN_HPP_NAMESPACE PresentFrameTokenGGP & operator=( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PresentFrameTokenGGP ) - offsetof( PresentFrameTokenGGP, pNext ) ); + pNext = rhs.pNext; + frameToken = rhs.frameToken; + return *this; } @@ -74214,7 +75125,14 @@ namespace VULKAN_HPP_NAMESPACE PresentInfoKHR & operator=( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PresentInfoKHR ) - offsetof( PresentInfoKHR, pNext ) ); + pNext = rhs.pNext; + waitSemaphoreCount = rhs.waitSemaphoreCount; + pWaitSemaphores = rhs.pWaitSemaphores; + swapchainCount = rhs.swapchainCount; + pSwapchains = rhs.pSwapchains; + pImageIndices = rhs.pImageIndices; + pResults = rhs.pResults; + return *this; } @@ -74543,7 +75461,10 @@ namespace VULKAN_HPP_NAMESPACE PresentRegionsKHR & operator=( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PresentRegionsKHR ) - offsetof( PresentRegionsKHR, pNext ) ); + pNext = rhs.pNext; + swapchainCount = rhs.swapchainCount; + pRegions = rhs.pRegions; + return *this; } @@ -74716,7 +75637,10 @@ namespace VULKAN_HPP_NAMESPACE PresentTimesInfoGOOGLE & operator=( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( PresentTimesInfoGOOGLE ) - offsetof( PresentTimesInfoGOOGLE, pNext ) ); + pNext = rhs.pNext; + swapchainCount = rhs.swapchainCount; + pTimes = rhs.pTimes; + return *this; } @@ -74814,8 +75738,9 @@ namespace VULKAN_HPP_NAMESPACE PrivateDataSlotCreateInfoEXT & operator=( PrivateDataSlotCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( PrivateDataSlotCreateInfoEXT ) - offsetof( PrivateDataSlotCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -74896,7 +75821,9 @@ namespace VULKAN_HPP_NAMESPACE ProtectedSubmitInfo & operator=( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ProtectedSubmitInfo ) - offsetof( ProtectedSubmitInfo, pNext ) ); + pNext = rhs.pNext; + protectedSubmit = rhs.protectedSubmit; + return *this; } @@ -74982,7 +75909,12 @@ namespace VULKAN_HPP_NAMESPACE QueryPoolCreateInfo & operator=( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( QueryPoolCreateInfo ) - offsetof( QueryPoolCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + queryType = rhs.queryType; + queryCount = rhs.queryCount; + pipelineStatistics = rhs.pipelineStatistics; + return *this; } @@ -75100,9 +76032,11 @@ namespace VULKAN_HPP_NAMESPACE QueryPoolPerformanceCreateInfoKHR & operator=( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( QueryPoolPerformanceCreateInfoKHR ) - offsetof( QueryPoolPerformanceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + queueFamilyIndex = rhs.queueFamilyIndex; + counterIndexCount = rhs.counterIndexCount; + pCounterIndices = rhs.pCounterIndices; + return *this; } @@ -75213,10 +76147,9 @@ namespace VULKAN_HPP_NAMESPACE QueryPoolPerformanceQueryCreateInfoINTEL & operator=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( QueryPoolPerformanceQueryCreateInfoINTEL ) - - offsetof( QueryPoolPerformanceQueryCreateInfoINTEL, pNext ) ); + pNext = rhs.pNext; + performanceCountersSampling = rhs.performanceCountersSampling; + return *this; } @@ -75302,9 +76235,9 @@ namespace VULKAN_HPP_NAMESPACE QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( QueueFamilyCheckpointPropertiesNV ) - offsetof( QueueFamilyCheckpointPropertiesNV, pNext ) ); + pNext = rhs.pNext; + checkpointExecutionStageMask = rhs.checkpointExecutionStageMask; + return *this; } @@ -75436,7 +76369,9 @@ namespace VULKAN_HPP_NAMESPACE QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( QueueFamilyProperties2 ) - offsetof( QueueFamilyProperties2, pNext ) ); + pNext = rhs.pNext; + queueFamilyProperties = rhs.queueFamilyProperties; + return *this; } @@ -75518,9 +76453,14 @@ namespace VULKAN_HPP_NAMESPACE RayTracingShaderGroupCreateInfoKHR & operator=( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RayTracingShaderGroupCreateInfoKHR ) - offsetof( RayTracingShaderGroupCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + generalShader = rhs.generalShader; + closestHitShader = rhs.closestHitShader; + anyHitShader = rhs.anyHitShader; + intersectionShader = rhs.intersectionShader; + pShaderGroupCaptureReplayHandle = rhs.pShaderGroupCaptureReplayHandle; + return *this; } @@ -75651,10 +76591,11 @@ namespace VULKAN_HPP_NAMESPACE RayTracingPipelineInterfaceCreateInfoKHR & operator=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RayTracingPipelineInterfaceCreateInfoKHR ) - - offsetof( RayTracingPipelineInterfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + maxPayloadSize = rhs.maxPayloadSize; + maxAttributeSize = rhs.maxAttributeSize; + maxCallableSize = rhs.maxCallableSize; + return *this; } @@ -75800,9 +76741,19 @@ namespace VULKAN_HPP_NAMESPACE RayTracingPipelineCreateInfoKHR & operator=( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RayTracingPipelineCreateInfoKHR ) - offsetof( RayTracingPipelineCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + stageCount = rhs.stageCount; + pStages = rhs.pStages; + groupCount = rhs.groupCount; + pGroups = rhs.pGroups; + maxRecursionDepth = rhs.maxRecursionDepth; + libraries = rhs.libraries; + pLibraryInterface = rhs.pLibraryInterface; + layout = rhs.layout; + basePipelineHandle = rhs.basePipelineHandle; + basePipelineIndex = rhs.basePipelineIndex; + return *this; } @@ -75996,9 +76947,13 @@ namespace VULKAN_HPP_NAMESPACE RayTracingShaderGroupCreateInfoNV & operator=( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RayTracingShaderGroupCreateInfoNV ) - offsetof( RayTracingShaderGroupCreateInfoNV, pNext ) ); + pNext = rhs.pNext; + type = rhs.type; + generalShader = rhs.generalShader; + closestHitShader = rhs.closestHitShader; + anyHitShader = rhs.anyHitShader; + intersectionShader = rhs.intersectionShader; + return *this; } @@ -76150,9 +77105,17 @@ namespace VULKAN_HPP_NAMESPACE RayTracingPipelineCreateInfoNV & operator=( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RayTracingPipelineCreateInfoNV ) - offsetof( RayTracingPipelineCreateInfoNV, pNext ) ); + 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; } @@ -76377,9 +77340,10 @@ namespace VULKAN_HPP_NAMESPACE RenderPassAttachmentBeginInfo & operator=( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassAttachmentBeginInfo ) - offsetof( RenderPassAttachmentBeginInfo, pNext ) ); + pNext = rhs.pNext; + attachmentCount = rhs.attachmentCount; + pAttachments = rhs.pAttachments; + return *this; } @@ -76502,7 +77466,13 @@ namespace VULKAN_HPP_NAMESPACE RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( RenderPassBeginInfo ) - offsetof( RenderPassBeginInfo, pNext ) ); + pNext = rhs.pNext; + renderPass = rhs.renderPass; + framebuffer = rhs.framebuffer; + renderArea = rhs.renderArea; + clearValueCount = rhs.clearValueCount; + pClearValues = rhs.pClearValues; + return *this; } @@ -76996,7 +77966,15 @@ namespace VULKAN_HPP_NAMESPACE RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo ) - offsetof( RenderPassCreateInfo, pNext ) ); + 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; } @@ -77215,7 +78193,19 @@ namespace VULKAN_HPP_NAMESPACE SubpassDescription2 & operator=( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SubpassDescription2 ) - offsetof( SubpassDescription2, pNext ) ); + 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; } @@ -77433,7 +78423,16 @@ namespace VULKAN_HPP_NAMESPACE SubpassDependency2 & operator=( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SubpassDependency2 ) - offsetof( SubpassDependency2, pNext ) ); + 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; } @@ -77604,7 +78603,17 @@ namespace VULKAN_HPP_NAMESPACE RenderPassCreateInfo2 & operator=( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( RenderPassCreateInfo2 ) - offsetof( RenderPassCreateInfo2, pNext ) ); + 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; } @@ -77795,10 +78804,9 @@ namespace VULKAN_HPP_NAMESPACE RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassFragmentDensityMapCreateInfoEXT ) - - offsetof( RenderPassFragmentDensityMapCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + fragmentDensityMapAttachment = rhs.fragmentDensityMapAttachment; + return *this; } @@ -77897,10 +78905,10 @@ namespace VULKAN_HPP_NAMESPACE RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassInputAttachmentAspectCreateInfo ) - - offsetof( RenderPassInputAttachmentAspectCreateInfo, pNext ) ); + pNext = rhs.pNext; + aspectReferenceCount = rhs.aspectReferenceCount; + pAspectReferences = rhs.pAspectReferences; + return *this; } @@ -78026,9 +79034,14 @@ namespace VULKAN_HPP_NAMESPACE RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassMultiviewCreateInfo ) - offsetof( RenderPassMultiviewCreateInfo, pNext ) ); + pNext = rhs.pNext; + subpassCount = rhs.subpassCount; + pViewMasks = rhs.pViewMasks; + dependencyCount = rhs.dependencyCount; + pViewOffsets = rhs.pViewOffsets; + correlationMaskCount = rhs.correlationMaskCount; + pCorrelationMasks = rhs.pCorrelationMasks; + return *this; } @@ -78267,10 +79280,12 @@ namespace VULKAN_HPP_NAMESPACE RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassSampleLocationsBeginInfoEXT ) - - offsetof( RenderPassSampleLocationsBeginInfoEXT, pNext ) ); + pNext = rhs.pNext; + attachmentInitialSampleLocationsCount = rhs.attachmentInitialSampleLocationsCount; + pAttachmentInitialSampleLocations = rhs.pAttachmentInitialSampleLocations; + postSubpassSampleLocationsCount = rhs.postSubpassSampleLocationsCount; + pPostSubpassSampleLocations = rhs.pPostSubpassSampleLocations; + return *this; } @@ -78403,9 +79418,9 @@ namespace VULKAN_HPP_NAMESPACE RenderPassTransformBeginInfoQCOM & operator=( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( RenderPassTransformBeginInfoQCOM ) - offsetof( RenderPassTransformBeginInfoQCOM, pNext ) ); + pNext = rhs.pNext; + transform = rhs.transform; + return *this; } @@ -78518,7 +79533,24 @@ namespace VULKAN_HPP_NAMESPACE SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SamplerCreateInfo ) - offsetof( SamplerCreateInfo, pNext ) ); + 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; } @@ -78716,10 +79748,10 @@ namespace VULKAN_HPP_NAMESPACE SamplerCustomBorderColorCreateInfoEXT & operator=( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SamplerCustomBorderColorCreateInfoEXT ) - - offsetof( SamplerCustomBorderColorCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + customBorderColor = rhs.customBorderColor; + format = rhs.format; + return *this; } @@ -78795,9 +79827,9 @@ namespace VULKAN_HPP_NAMESPACE SamplerReductionModeCreateInfo & operator=( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SamplerReductionModeCreateInfo ) - offsetof( SamplerReductionModeCreateInfo, pNext ) ); + pNext = rhs.pNext; + reductionMode = rhs.reductionMode; + return *this; } @@ -78895,9 +79927,16 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversionCreateInfo & operator=( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SamplerYcbcrConversionCreateInfo ) - offsetof( SamplerYcbcrConversionCreateInfo, pNext ) ); + 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; } @@ -79041,10 +80080,9 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversionImageFormatProperties & operator=( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SamplerYcbcrConversionImageFormatProperties ) - - offsetof( SamplerYcbcrConversionImageFormatProperties, pNext ) ); + pNext = rhs.pNext; + combinedImageSamplerDescriptorCount = rhs.combinedImageSamplerDescriptorCount; + return *this; } @@ -79115,8 +80153,9 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversionInfo & operator=( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( SamplerYcbcrConversionInfo ) - offsetof( SamplerYcbcrConversionInfo, pNext ) ); + pNext = rhs.pNext; + conversion = rhs.conversion; + return *this; } @@ -79198,7 +80237,9 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreCreateInfo & operator=( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreCreateInfo ) - offsetof( SemaphoreCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + return *this; } @@ -79281,7 +80322,10 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreGetFdInfoKHR & operator=( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreGetFdInfoKHR ) - offsetof( SemaphoreGetFdInfoKHR, pNext ) ); + pNext = rhs.pNext; + semaphore = rhs.semaphore; + handleType = rhs.handleType; + return *this; } @@ -79375,9 +80419,10 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreGetWin32HandleInfoKHR & operator=( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SemaphoreGetWin32HandleInfoKHR ) - offsetof( SemaphoreGetWin32HandleInfoKHR, pNext ) ); + pNext = rhs.pNext; + semaphore = rhs.semaphore; + handleType = rhs.handleType; + return *this; } @@ -79470,7 +80515,10 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreSignalInfo & operator=( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreSignalInfo ) - offsetof( SemaphoreSignalInfo, pNext ) ); + pNext = rhs.pNext; + semaphore = rhs.semaphore; + value = rhs.value; + return *this; } @@ -79560,7 +80608,10 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreTypeCreateInfo & operator=( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreTypeCreateInfo ) - offsetof( SemaphoreTypeCreateInfo, pNext ) ); + pNext = rhs.pNext; + semaphoreType = rhs.semaphoreType; + initialValue = rhs.initialValue; + return *this; } @@ -79675,7 +80726,12 @@ namespace VULKAN_HPP_NAMESPACE SemaphoreWaitInfo & operator=( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SemaphoreWaitInfo ) - offsetof( SemaphoreWaitInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + semaphoreCount = rhs.semaphoreCount; + pSemaphores = rhs.pSemaphores; + pValues = rhs.pValues; + return *this; } @@ -79864,7 +80920,11 @@ namespace VULKAN_HPP_NAMESPACE ShaderModuleCreateInfo & operator=( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ShaderModuleCreateInfo ) - offsetof( ShaderModuleCreateInfo, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + codeSize = rhs.codeSize; + pCode = rhs.pCode; + return *this; } @@ -79973,10 +81033,9 @@ namespace VULKAN_HPP_NAMESPACE ShaderModuleValidationCacheCreateInfoEXT & operator=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( ShaderModuleValidationCacheCreateInfoEXT ) - - offsetof( ShaderModuleValidationCacheCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + validationCache = rhs.validationCache; + return *this; } @@ -80199,9 +81258,9 @@ namespace VULKAN_HPP_NAMESPACE SharedPresentSurfaceCapabilitiesKHR & operator=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SharedPresentSurfaceCapabilitiesKHR ) - offsetof( SharedPresentSurfaceCapabilitiesKHR, pNext ) ); + pNext = rhs.pNext; + sharedPresentSupportedUsageFlags = rhs.sharedPresentSupportedUsageFlags; + return *this; } @@ -80329,8 +81388,9 @@ namespace VULKAN_HPP_NAMESPACE SparseImageFormatProperties2 & operator=( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( SparseImageFormatProperties2 ) - offsetof( SparseImageFormatProperties2, pNext ) ); + pNext = rhs.pNext; + properties = rhs.properties; + return *this; } @@ -80465,9 +81525,9 @@ namespace VULKAN_HPP_NAMESPACE SparseImageMemoryRequirements2 & operator=( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SparseImageMemoryRequirements2 ) - offsetof( SparseImageMemoryRequirements2, pNext ) ); + pNext = rhs.pNext; + memoryRequirements = rhs.memoryRequirements; + return *this; } @@ -80542,10 +81602,10 @@ namespace VULKAN_HPP_NAMESPACE StreamDescriptorSurfaceCreateInfoGGP & operator=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( StreamDescriptorSurfaceCreateInfoGGP ) - - offsetof( StreamDescriptorSurfaceCreateInfoGGP, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + streamDescriptor = rhs.streamDescriptor; + return *this; } @@ -80772,7 +81832,15 @@ namespace VULKAN_HPP_NAMESPACE SubmitInfo & operator=( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SubmitInfo ) - offsetof( SubmitInfo, pNext ) ); + 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; } @@ -80941,7 +82009,9 @@ namespace VULKAN_HPP_NAMESPACE SubpassBeginInfo & operator=( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SubpassBeginInfo ) - offsetof( SubpassBeginInfo, pNext ) ); + pNext = rhs.pNext; + contents = rhs.contents; + return *this; } @@ -81028,10 +82098,11 @@ namespace VULKAN_HPP_NAMESPACE SubpassDescriptionDepthStencilResolve & operator=( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SubpassDescriptionDepthStencilResolve ) - - offsetof( SubpassDescriptionDepthStencilResolve, pNext ) ); + pNext = rhs.pNext; + depthResolveMode = rhs.depthResolveMode; + stencilResolveMode = rhs.stencilResolveMode; + pDepthStencilResolveAttachment = rhs.pDepthStencilResolveAttachment; + return *this; } @@ -81128,7 +82199,8 @@ namespace VULKAN_HPP_NAMESPACE SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SubpassEndInfo ) - offsetof( SubpassEndInfo, pNext ) ); + pNext = rhs.pNext; + return *this; } @@ -81221,7 +82293,19 @@ namespace VULKAN_HPP_NAMESPACE SurfaceCapabilities2EXT & operator=( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SurfaceCapabilities2EXT ) - offsetof( SurfaceCapabilities2EXT, pNext ) ); + 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; } @@ -81392,7 +82476,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceCapabilities2KHR & operator=( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SurfaceCapabilities2KHR ) - offsetof( SurfaceCapabilities2KHR, pNext ) ); + pNext = rhs.pNext; + surfaceCapabilities = rhs.surfaceCapabilities; + return *this; } @@ -81465,10 +82551,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SurfaceCapabilitiesFullScreenExclusiveEXT ) - - offsetof( SurfaceCapabilitiesFullScreenExclusiveEXT, pNext ) ); + pNext = rhs.pNext; + fullScreenExclusiveSupported = rhs.fullScreenExclusiveSupported; + return *this; } @@ -81608,7 +82693,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceFormat2KHR & operator=( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SurfaceFormat2KHR ) - offsetof( SurfaceFormat2KHR, pNext ) ); + pNext = rhs.pNext; + surfaceFormat = rhs.surfaceFormat; + return *this; } @@ -81679,9 +82766,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceFullScreenExclusiveInfoEXT & operator=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SurfaceFullScreenExclusiveInfoEXT ) - offsetof( SurfaceFullScreenExclusiveInfoEXT, pNext ) ); + pNext = rhs.pNext; + fullScreenExclusive = rhs.fullScreenExclusive; + return *this; } @@ -81768,10 +82855,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceFullScreenExclusiveWin32InfoEXT & operator=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SurfaceFullScreenExclusiveWin32InfoEXT ) - - offsetof( SurfaceFullScreenExclusiveWin32InfoEXT, pNext ) ); + pNext = rhs.pNext; + hmonitor = rhs.hmonitor; + return *this; } @@ -81853,9 +82939,9 @@ namespace VULKAN_HPP_NAMESPACE SurfaceProtectedCapabilitiesKHR & operator=( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SurfaceProtectedCapabilitiesKHR ) - offsetof( SurfaceProtectedCapabilitiesKHR, pNext ) ); + pNext = rhs.pNext; + supportsProtected = rhs.supportsProtected; + return *this; } @@ -81937,9 +83023,9 @@ namespace VULKAN_HPP_NAMESPACE SwapchainCounterCreateInfoEXT & operator=( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SwapchainCounterCreateInfoEXT ) - offsetof( SwapchainCounterCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + surfaceCounters = rhs.surfaceCounters; + return *this; } @@ -82091,7 +83177,24 @@ namespace VULKAN_HPP_NAMESPACE SwapchainCreateInfoKHR & operator=( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( SwapchainCreateInfoKHR ) - offsetof( SwapchainCreateInfoKHR, pNext ) ); + 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; } @@ -82301,10 +83404,9 @@ namespace VULKAN_HPP_NAMESPACE SwapchainDisplayNativeHdrCreateInfoAMD & operator=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( SwapchainDisplayNativeHdrCreateInfoAMD ) - - offsetof( SwapchainDisplayNativeHdrCreateInfoAMD, pNext ) ); + pNext = rhs.pNext; + localDimmingEnable = rhs.localDimmingEnable; + return *this; } @@ -82389,9 +83491,9 @@ namespace VULKAN_HPP_NAMESPACE TextureLODGatherFormatPropertiesAMD & operator=( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( TextureLODGatherFormatPropertiesAMD ) - offsetof( TextureLODGatherFormatPropertiesAMD, pNext ) ); + pNext = rhs.pNext; + supportsTextureGatherLODBiasAMD = rhs.supportsTextureGatherLODBiasAMD; + return *this; } @@ -82478,8 +83580,12 @@ namespace VULKAN_HPP_NAMESPACE TimelineSemaphoreSubmitInfo & operator=( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( TimelineSemaphoreSubmitInfo ) - offsetof( TimelineSemaphoreSubmitInfo, pNext ) ); + pNext = rhs.pNext; + waitSemaphoreValueCount = rhs.waitSemaphoreValueCount; + pWaitSemaphoreValues = rhs.pWaitSemaphoreValues; + signalSemaphoreValueCount = rhs.signalSemaphoreValueCount; + pSignalSemaphoreValues = rhs.pSignalSemaphoreValues; + return *this; } @@ -82699,8 +83805,11 @@ namespace VULKAN_HPP_NAMESPACE ValidationCacheCreateInfoEXT & operator=( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( ValidationCacheCreateInfoEXT ) - offsetof( ValidationCacheCreateInfoEXT, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + initialDataSize = rhs.initialDataSize; + pInitialData = rhs.pInitialData; + return *this; } @@ -82827,7 +83936,12 @@ namespace VULKAN_HPP_NAMESPACE ValidationFeaturesEXT & operator=( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ValidationFeaturesEXT ) - offsetof( ValidationFeaturesEXT, pNext ) ); + pNext = rhs.pNext; + enabledValidationFeatureCount = rhs.enabledValidationFeatureCount; + pEnabledValidationFeatures = rhs.pEnabledValidationFeatures; + disabledValidationFeatureCount = rhs.disabledValidationFeatureCount; + pDisabledValidationFeatures = rhs.pDisabledValidationFeatures; + return *this; } @@ -82969,7 +84083,10 @@ namespace VULKAN_HPP_NAMESPACE ValidationFlagsEXT & operator=( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ValidationFlagsEXT ) - offsetof( ValidationFlagsEXT, pNext ) ); + pNext = rhs.pNext; + disabledValidationCheckCount = rhs.disabledValidationCheckCount; + pDisabledValidationChecks = rhs.pDisabledValidationChecks; + return *this; } @@ -83072,7 +84189,10 @@ namespace VULKAN_HPP_NAMESPACE ViSurfaceCreateInfoNN & operator=( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( ViSurfaceCreateInfoNN ) - offsetof( ViSurfaceCreateInfoNN, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + window = rhs.window; + return *this; } @@ -83164,8 +84284,11 @@ namespace VULKAN_HPP_NAMESPACE WaylandSurfaceCreateInfoKHR & operator=( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( - &pNext, &rhs.pNext, sizeof( WaylandSurfaceCreateInfoKHR ) - offsetof( WaylandSurfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + display = rhs.display; + surface = rhs.surface; + return *this; } @@ -83333,10 +84456,15 @@ namespace VULKAN_HPP_NAMESPACE Win32KeyedMutexAcquireReleaseInfoKHR & operator=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) - - offsetof( Win32KeyedMutexAcquireReleaseInfoKHR, pNext ) ); + 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; } @@ -83587,9 +84715,15 @@ namespace VULKAN_HPP_NAMESPACE Win32KeyedMutexAcquireReleaseInfoNV & operator=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) - offsetof( Win32KeyedMutexAcquireReleaseInfoNV, pNext ) ); + 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; } @@ -83777,7 +84911,11 @@ namespace VULKAN_HPP_NAMESPACE Win32SurfaceCreateInfoKHR & operator=( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( Win32SurfaceCreateInfoKHR ) - offsetof( Win32SurfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + hinstance = rhs.hinstance; + hwnd = rhs.hwnd; + return *this; } @@ -83923,7 +85061,16 @@ namespace VULKAN_HPP_NAMESPACE WriteDescriptorSet & operator=( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( WriteDescriptorSet ) - offsetof( WriteDescriptorSet, pNext ) ); + 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; } @@ -84107,10 +85254,10 @@ namespace VULKAN_HPP_NAMESPACE WriteDescriptorSetAccelerationStructureKHR & operator=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( WriteDescriptorSetAccelerationStructureKHR ) - - offsetof( WriteDescriptorSetAccelerationStructureKHR, pNext ) ); + pNext = rhs.pNext; + accelerationStructureCount = rhs.accelerationStructureCount; + pAccelerationStructures = rhs.pAccelerationStructures; + return *this; } @@ -84225,10 +85372,10 @@ namespace VULKAN_HPP_NAMESPACE WriteDescriptorSetInlineUniformBlockEXT & operator=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, - &rhs.pNext, - sizeof( WriteDescriptorSetInlineUniformBlockEXT ) - - offsetof( WriteDescriptorSetInlineUniformBlockEXT, pNext ) ); + pNext = rhs.pNext; + dataSize = rhs.dataSize; + pData = rhs.pData; + return *this; } @@ -84332,7 +85479,11 @@ namespace VULKAN_HPP_NAMESPACE XcbSurfaceCreateInfoKHR & operator=( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( XcbSurfaceCreateInfoKHR ) - offsetof( XcbSurfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + connection = rhs.connection; + window = rhs.window; + return *this; } @@ -84432,7 +85583,11 @@ namespace VULKAN_HPP_NAMESPACE XlibSurfaceCreateInfoKHR & operator=( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT { - memcpy( &pNext, &rhs.pNext, sizeof( XlibSurfaceCreateInfoKHR ) - offsetof( XlibSurfaceCreateInfoKHR, pNext ) ); + pNext = rhs.pNext; + flags = rhs.flags; + dpy = rhs.dpy; + window = rhs.window; + return *this; }