From d16c62670b02dd3292aa8711702efebfc634645f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20S=C3=BC=C3=9Fenbach?= Date: Wed, 30 Jul 2025 09:36:58 +0200 Subject: [PATCH] Mark deprecated struct members as deprecated. (#2230) --- VulkanHppGenerator.cpp | 496 +++++++++++++++++++++++++---------- VulkanHppGenerator.hpp | 7 +- snippets/ResultValue.hpp | 3 +- snippets/macros.hpp | 5 + vulkan/vulkan.hpp | 5 +- vulkan/vulkan_hash.hpp | 8 - vulkan/vulkan_hpp_macros.hpp | 5 + vulkan/vulkan_structs.hpp | 120 ++++++--- 8 files changed, 453 insertions(+), 196 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index 33cb253..926ac99 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -1533,6 +1533,11 @@ bool VulkanHppGenerator::containsArray( std::string const & type ) const return found; } +bool VulkanHppGenerator::containsDeprecated( std::vector const & members ) const +{ + return std::ranges::any_of( members, []( auto const & member ) { return !member.deprecated.empty(); } ); +} + bool VulkanHppGenerator::containsFuncPointer( std::string const & type ) const { // a simple recursive check if a type contains a funcpointer @@ -5026,11 +5031,17 @@ std::string VulkanHppGenerator::generateCommandVoid2Return( std::string const & return ""; } -std::string VulkanHppGenerator::generateConstexprString( std::string const & structName ) const +std::string VulkanHppGenerator::generateConstexprString( std::pair const & structData ) const { // structs with a VkBaseInStructure and VkBaseOutStructure can't be a constexpr! - const bool isConstExpression = ( structName != "VkBaseInStructure" ) && ( structName != "VkBaseOutStructure" ); - return isConstExpression ? ( std::string( "VULKAN_HPP_CONSTEXPR" ) + ( ( containsUnion( structName ) || containsArray( structName ) ) ? "_14 " : " " ) ) : ""; + const bool isConstExpression = ( structData.first != "VkBaseInStructure" ) && ( structData.first != "VkBaseOutStructure" ); + return isConstExpression + ? ( std::string( "VULKAN_HPP_CONSTEXPR" ) + + ( containsDeprecated( structData.second.members ) + ? "_17 " + : ( ( containsUnion( structData.first ) || containsArray( structData.first ) || containsDeprecated( structData.second.members ) ) ? "_14 " + : " " ) ) ) + : ""; } std::string VulkanHppGenerator::generateConstexprDefines() const @@ -9507,7 +9518,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandFactory( std::string co handleType += "s"; } std::string decoratedReturnType = returnType; - if (!commandData.errorCodes.empty()) + if ( !commandData.errorCodes.empty() ) { decoratedReturnType = "typename ResultValueType<" + returnType + ">::type"; } @@ -11258,6 +11269,42 @@ std::string VulkanHppGenerator::generateStruct( std::pair const & structData ) const +{ + std::string castAssignments; + if ( containsDeprecated( structData.second.members ) ) + { + for ( auto const & member : structData.second.members ) + { + if ( member.deprecated.empty() && ( member.type.type != "VkStructureType" ) ) + { + if ( member.type.type.starts_with( "Vk" ) ) + { + if ( member.type.isValue() ) + { + castAssignments += member.name + " = static_cast<" + stripPrefix( member.type.type, "Vk" ) + ">( rhs." + member.name + " );\n"; + } + else + { + castAssignments += member.name + " = reinterpret_cast<" + member.type.compose( "Vk" ) + ">( rhs." + member.name + " );\n"; + } + } + else + { + castAssignments += member.name + " = rhs." + member.name + ";\n"; + } + } + } + } + else + { + castAssignments = "*this = *reinterpret_cast<" + stripPrefix( structData.first, "Vk" ) + " const *>( &rhs );\n"; + } + assert( castAssignments.ends_with( "\n" ) ); + castAssignments.pop_back(); + return castAssignments; +} + std::string VulkanHppGenerator::generateStructCompareOperators( std::pair const & structData ) const { static const std::set simpleTypes = { "char", "double", "DWORD", "float", "HANDLE", "HINSTANCE", "HMONITOR", @@ -11271,97 +11318,101 @@ std::string VulkanHppGenerator::generateStructCompareOperators( std::pairsecond.category == TypeCategory::ExternalType ) && member.type.postfix.empty() && !simpleTypes.contains( member.type.type ) ) + if ( member.deprecated.empty() ) { - nonDefaultCompare = true; - // this type might support operator==() or operator<=>()... that is, use memcmp - compareMembers += intro + "( memcmp( &" + member.name + ", &rhs." + member.name + ", sizeof( " + member.type.type + " ) ) == 0 )"; + auto typeIt = m_types.find( member.type.type ); + assert( typeIt != m_types.end() ); + if ( ( typeIt->second.category == TypeCategory::ExternalType ) && member.type.postfix.empty() && !simpleTypes.contains( member.type.type ) ) + { + nonDefaultCompare = true; + // this type might support operator==() or operator<=>()... that is, use memcmp + compareMembers += intro + "( memcmp( &" + member.name + ", &rhs." + member.name + ", sizeof( " + member.type.type + " ) ) == 0 )"; - static const std::string spaceshipMemberTemplate = - R"( if ( auto cmp = memcmp( &${name}, &rhs.${name}, sizeof( ${type} ) ); cmp != 0 ) + static const std::string spaceshipMemberTemplate = + R"( if ( auto cmp = memcmp( &${name}, &rhs.${name}, sizeof( ${type} ) ); cmp != 0 ) return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater; )"; - spaceshipMembers += - replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering }, { "type", member.type.type } } ); - } - else if ( member.type.type == "char" && !member.lenExpressions.empty() ) - { - // compare null-terminated strings - nonDefaultCompare = true; - assert( member.lenExpressions.size() < 3 ); - if ( member.lenExpressions.size() == 1 ) + spaceshipMembers += + replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering }, { "type", member.type.type } } ); + } + else if ( member.type.type == "char" && !member.lenExpressions.empty() ) { - assert( member.lenExpressions[0] == "null-terminated" ); - if ( member.arraySizes.empty() ) + // compare null-terminated strings + nonDefaultCompare = true; + assert( member.lenExpressions.size() < 3 ); + if ( member.lenExpressions.size() == 1 ) { - compareMembers += intro + "( ( " + member.name + " == rhs." + member.name + " ) || ( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 ) )"; + assert( member.lenExpressions[0] == "null-terminated" ); + if ( member.arraySizes.empty() ) + { + compareMembers += + intro + "( ( " + member.name + " == rhs." + member.name + " ) || ( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 ) )"; - static const std::string spaceshipMemberTemplate = - R"( if ( ${name} != rhs.${name} ) + static const std::string spaceshipMemberTemplate = + R"( if ( ${name} != rhs.${name} ) if ( auto cmp = strcmp( ${name}, rhs.${name} ); cmp != 0 ) return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater; )"; - spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering } } ); + spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering } } ); + } + else + { + assert( member.arraySizes.size() == 1 ); + compareMembers += intro + "( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 )"; + + static const std::string spaceshipMemberTemplate = + R"( if ( auto cmp = strcmp( ${name}, rhs.${name} ); cmp != 0 ) + return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater; +)"; + spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering } } ); + } } else { - assert( member.arraySizes.size() == 1 ); - compareMembers += intro + "( strcmp( " + member.name + ", rhs." + member.name + " ) == 0 )"; + assert( member.lenExpressions[1] == "null-terminated" ); + assert( ( member.type.prefix == "const" ) && ( member.type.postfix == "* const *" ) ); + static const std::string compareMemberTemplate = + R"(std::equal( ${name}, ${name} + ${count}, rhs.${name}, []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ))"; + compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name } } ); - static const std::string spaceshipMemberTemplate = - R"( if ( auto cmp = strcmp( ${name}, rhs.${name} ); cmp != 0 ) - return ( cmp < 0 ) ? ${ordering}::less : ${ordering}::greater; -)"; - spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "name", member.name }, { "ordering", spaceshipOrdering } } ); - } - } - else - { - assert( member.lenExpressions[1] == "null-terminated" ); - assert( ( member.type.prefix == "const" ) && ( member.type.postfix == "* const *" ) ); - static const std::string compareMemberTemplate = - R"(std::equal( ${name}, ${name} + ${count}, rhs.${name}, []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ))"; - compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name } } ); - - static const std::string spaceshipMemberTemplate = R"( for ( size_t i = 0; i < ${count}; ++i ) + static const std::string spaceshipMemberTemplate = R"( for ( size_t i = 0; i < ${count}; ++i ) { if ( ${name}[i] != rhs.${name}[i] ) if ( auto cmp = strcmp( ${name}[i], rhs.${name}[i] ); cmp != 0 ) return cmp < 0 ? ${ordering}::less : ${ordering}::greater; } )"; - spaceshipMembers += - replaceWithMap( spaceshipMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "ordering", spaceshipOrdering } } ); + spaceshipMembers += + replaceWithMap( spaceshipMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "ordering", spaceshipOrdering } } ); + } } - } - else if ( !member.arraySizes.empty() && !member.lenExpressions.empty() ) - { - nonDefaultCompare = true; + else if ( !member.arraySizes.empty() && !member.lenExpressions.empty() ) + { + nonDefaultCompare = true; - assert( ( member.arraySizes.size() == 1 ) && ( member.lenExpressions.size() == 1 ) ); - assert( std::ranges::any_of( structData.second.members, [&member]( MemberData const & m ) { return m.name == member.lenExpressions[0]; } ) ); + assert( ( member.arraySizes.size() == 1 ) && ( member.lenExpressions.size() == 1 ) ); + assert( std::ranges::any_of( structData.second.members, [&member]( MemberData const & m ) { return m.name == member.lenExpressions[0]; } ) ); - std::string type = member.type.compose( "Vk" ); + std::string type = member.type.compose( "Vk" ); - static const std::string compareMemberTemplate = R"(( memcmp( ${name}, rhs.${name}, ${count} * sizeof( ${type} ) ) == 0 ))"; - compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "type", type } } ); + static const std::string compareMemberTemplate = R"(( memcmp( ${name}, rhs.${name}, ${count} * sizeof( ${type} ) ) == 0 ))"; + compareMembers += intro + replaceWithMap( compareMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name }, { "type", type } } ); - static const std::string spaceshipMemberTemplate = R"( for ( size_t i = 0; i < ${count}; ++i ) + static const std::string spaceshipMemberTemplate = R"( for ( size_t i = 0; i < ${count}; ++i ) { if ( auto cmp = ${name}[i] <=> rhs.${name}[i]; cmp != 0 ) return cmp; } )"; - spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name } } ); + spaceshipMembers += replaceWithMap( spaceshipMemberTemplate, { { "count", member.lenExpressions[0] }, { "name", member.name } } ); + } + else + { + // for all others, we use the operator== of that type + compareMembers += intro + "( " + member.name + " == rhs." + member.name + " )"; + spaceshipMembers += " if ( auto cmp = " + member.name + " <=> rhs." + member.name + "; cmp != 0 ) return cmp;\n"; + } + intro = "\n && "; } - else - { - // for all others, we use the operator== of that type - compareMembers += intro + "( " + member.name + " == rhs." + member.name + " )"; - spaceshipMembers += " if ( auto cmp = " + member.name + " <=> rhs." + member.name + "; cmp != 0 ) return cmp;\n"; - } - intro = "\n && "; } std::string structName = stripPrefix( structData.first, "Vk" ); @@ -11433,18 +11484,22 @@ std::string VulkanHppGenerator::generateStructConstructors( std::pair( &rhs ) ) {} + + ${enhancedConstructors} +${popIgnored} )"; std::vector arguments, initializers; + std::string ignores; for ( auto const & member : structData.second.members ) { // gather the arguments @@ -11454,12 +11509,48 @@ std::string VulkanHppGenerator::generateStructConstructors( std::pair arguments, initializers; bool arrayListed = false; - std::string templateHeader, sizeChecks, copyOps; + std::string ignores, templateHeader, sizeChecks, copyOps; for ( auto mit = structData.second.members.begin(); mit != structData.second.members.end(); ++mit ) { // gather the initializers @@ -11555,9 +11647,12 @@ ${byString} auto litit = lenIts.find( mit ); if ( litit != lenIts.end() ) { - // len arguments just have an initalizer, from the array size - initializers.push_back( mit->name + "( " + generateLenInitializer( mit, litit, structData.second.mutualExclusiveLens ) + " )" ); - sizeChecks += generateSizeCheck( litit->second, stripPrefix( structData.first, "Vk" ), structData.second.mutualExclusiveLens ); + if ( mit->deprecated.empty() ) + { + // len arguments just have an initalizer, from the array size + initializers.push_back( mit->name + "( " + generateLenInitializer( mit, litit, structData.second.mutualExclusiveLens ) + " )" ); + sizeChecks += generateSizeCheck( litit->second, stripPrefix( structData.first, "Vk" ), structData.second.mutualExclusiveLens ); + } } else if ( hasLen( *mit, structData.second.members ) ) { @@ -11602,11 +11697,18 @@ ${byString} if ( mit->type.isPointer() ) { - initializers.push_back( mit->name + "( " + argumentName + ".data() )" ); + if ( mit->deprecated.empty() ) + { + initializers.push_back( mit->name + "( " + argumentName + ".data() )" ); + } + else + { + ignores += "detail::ignore( " + argumentName + " );\n"; + } } else { - assert( mit->arraySizes.size() == 1 ); + assert( mit->deprecated.empty() && ( mit->arraySizes.size() == 1 ) ); if ( mit->lenExpressions[0] == "null-terminated" ) { static const std::string strcpyTemplate = R"( @@ -11640,6 +11742,7 @@ ${byString} } else { + assert( mit->deprecated.empty() ); std::string argument = generateStructConstructorArgument( *mit, arrayListed ); if ( !argument.empty() ) { @@ -11661,13 +11764,18 @@ ${byString} #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) ${templateHeader} ${structName}( ${arguments} ) ${initializers} - {${sizeChecks}${copyOps}} + { + ${ignores} + ${sizeChecks} + ${copyOps} + } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ )"; return replaceWithMap( constructorTemplate, { { "arguments", generateList( arguments, "", ", " ) }, { "copyOps", copyOps }, + { "ignores", ignores }, { "initializers", generateList( initializers, ": ", ", " ) }, { "sizeChecks", sizeChecks }, { "structName", stripPrefix( structData.first, "Vk" ) }, @@ -11720,6 +11828,77 @@ std::string VulkanHppGenerator::generateStructConstructorArgument( MemberData co return str; } +std::string VulkanHppGenerator::generateStructCopyAssignment( std::pair const & structData ) const +{ + std::string copyAssignment; + if ( containsDeprecated( structData.second.members ) ) + { + static const std::string copyAssignmentTemplate = R"(${structName} & operator=( ${structName} const & rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + ${initializers} + } + return *this; + })"; + + std::vector initializers; + for ( auto const & member : structData.second.members ) + { + if ( member.deprecated.empty() && ( member.type.type != "VkStructureType" ) ) + { + initializers.push_back( member.name + " = rhs." + member.name + ";" ); + } + } + copyAssignment = replaceWithMap( copyAssignmentTemplate, + { { "initializers", generateList( initializers, "", "\n" ) }, { "structName", stripPrefix( structData.first, "Vk" ) } } ); + } + else + { + static const std::string copyAssignmentTemplate = R"( + ${structName} & operator=( ${structName} const & rhs ) VULKAN_HPP_NOEXCEPT = default;)"; + + copyAssignment = replaceWithMap( copyAssignmentTemplate, { { "structName", stripPrefix( structData.first, "Vk" ) } } ); + } + return copyAssignment; +} + +std::string VulkanHppGenerator::generateStructCopyConstructor( std::pair const & structData ) const +{ + std::string copyConstructor; + if ( containsDeprecated( structData.second.members ) ) + { + static const std::string copyConstructorTemplate = R"(${constexpr}${structName}( ${structName} const & rhs ) VULKAN_HPP_NOEXCEPT + ${initializers} + {})"; + + std::vector initializers; + for ( auto const & member : structData.second.members ) + { + if ( member.deprecated.empty() && ( member.type.type != "VkStructureType" ) ) + { + initializers.push_back( member.name + "{ rhs." + member.name + " }" ); + } + } + + copyConstructor = replaceWithMap( copyConstructorTemplate, + { { "constexpr", generateConstexprString( structData ) }, + { "initializers", generateList( initializers, ": ", ", " ) }, + { "structName", stripPrefix( structData.first, "Vk" ) } } ); + } + else + { + static const std::string copyConstructorTemplate = R"( + ${constexpr}${structName}( ${structName} const & rhs ) VULKAN_HPP_NOEXCEPT = default; +)"; + + copyConstructor = replaceWithMap( copyConstructorTemplate, + { { "constexpr", generateConstexprString( structData ) }, { "structName", stripPrefix( structData.first, "Vk" ) } } ); + } + + return copyConstructor; +} + std::string VulkanHppGenerator::generateStructHashStructure( std::pair const & structure, std::set & listedStructs ) const { @@ -11800,50 +11979,53 @@ std::string VulkanHppGenerator::generateStructHashSum( std::string const & struc std::string hashSum; for ( auto const & member : members ) { - if ( !member.arraySizes.empty() ) + if ( member.deprecated.empty() ) { - assert( member.arraySizes.size() < 3 ); - hashSum += " for ( size_t i = 0; i < " + member.arraySizes[0] + "; ++i )\n"; - hashSum += " {\n"; - if ( member.arraySizes.size() == 1 ) + if ( !member.arraySizes.empty() ) { - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i] );\n"; + assert( member.arraySizes.size() < 3 ); + hashSum += " for ( size_t i = 0; i < " + member.arraySizes[0] + "; ++i )\n"; + hashSum += " {\n"; + if ( member.arraySizes.size() == 1 ) + { + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i] );\n"; + } + else + { + hashSum += " for ( size_t j=0; j < " + member.arraySizes[1] + "; ++j )\n"; + hashSum += " {\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i][j] );\n"; + hashSum += " }\n"; + } + hashSum += " }\n"; + } + else if ( member.type.type == "char" && !member.lenExpressions.empty() ) + { + assert( member.lenExpressions.size() < 3 ); + if ( member.lenExpressions.size() == 1 ) + { + assert( member.lenExpressions[0] == "null-terminated" ); + hashSum += " for ( const char* p = " + structName + "." + member.name + "; *p != '\\0'; ++p )\n"; + hashSum += " {\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, *p );\n"; + hashSum += " }\n"; + } + else + { + assert( member.lenExpressions[1] == "null-terminated" ); + hashSum += " for ( size_t i = 0; i < " + structName + "." + member.lenExpressions[0] + "; ++i )\n"; + hashSum += " {\n"; + hashSum += " for ( const char* p = " + structName + "." + member.name + "[i]; *p != '\\0'; ++p )\n"; + hashSum += " {\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, *p );\n"; + hashSum += " }\n"; + hashSum += " }\n"; + } } else { - hashSum += " for ( size_t j=0; j < " + member.arraySizes[1] + "; ++j )\n"; - hashSum += " {\n"; - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + "[i][j] );\n"; - hashSum += " }\n"; + hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + " );\n"; } - hashSum += " }\n"; - } - else if ( member.type.type == "char" && !member.lenExpressions.empty() ) - { - assert( member.lenExpressions.size() < 3 ); - if ( member.lenExpressions.size() == 1 ) - { - assert( member.lenExpressions[0] == "null-terminated" ); - hashSum += " for ( const char* p = " + structName + "." + member.name + "; *p != '\\0'; ++p )\n"; - hashSum += " {\n"; - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, *p );\n"; - hashSum += " }\n"; - } - else - { - assert( member.lenExpressions[1] == "null-terminated" ); - hashSum += " for ( size_t i = 0; i < " + structName + "." + member.lenExpressions[0] + "; ++i )\n"; - hashSum += " {\n"; - hashSum += " for ( const char* p = " + structName + "." + member.name + "[i]; *p != '\\0'; ++p )\n"; - hashSum += " {\n"; - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, *p );\n"; - hashSum += " }\n"; - hashSum += " }\n"; - } - } - else - { - hashSum += " VULKAN_HPP_HASH_COMBINE( seed, " + structName + "." + member.name + " );\n"; } } assert( !hashSum.empty() ); @@ -11961,18 +12143,20 @@ std::string VulkanHppGenerator::generateStructure( std::pair( &rhs ); + ${castAssignments} return *this; } )"; constructorsAndSetters = replaceWithMap( constructorsTemplate, - { { "constructors", generateStructConstructors( structure ) }, + { { "castAssignments", generateStructCastAssignments( structure ) }, + { "constructors", generateStructConstructors( structure ) }, + { "copyAssignment", generateStructCopyAssignment( structure ) }, { "deprecatedConstructors", generateDeprecatedConstructors( structure.first ) }, { "structName", stripPrefix( structure.first, "Vk" ) }, { "subConstructors", generateStructSubConstructor( structure ) } } ); @@ -12215,6 +12399,13 @@ std::tuple for ( auto const & member : structData.second.members ) { members += " "; + + if ( !member.deprecated.empty() ) + { + assert( member.deprecated == "ignored" ); + members += "VULKAN_HPP_DEPRECATED( \"" + member.deprecated + "\" ) "; + } + std::string type; if ( !member.bitCount.empty() && member.type.type.starts_with( "Vk" ) ) { @@ -12236,7 +12427,7 @@ std::tuple type = generateStandardArrayWrapper( member.type.compose( "Vk" ), member.arraySizes ); } members += type + " " + member.name; - if ( !member.value.empty() ) + if ( member.deprecated.empty() && !member.value.empty() ) { // special handling for members with legal value: use it as the default members += " = "; @@ -12263,10 +12454,11 @@ std::tuple assert( member.arraySizes.empty() || member.bitCount.empty() ); if ( !member.bitCount.empty() ) { + assert( member.deprecated.empty() ); members += " : " + member.bitCount; // except for bitfield members, where no default member initializatin // is supported (up to C++20) } - else + else if ( member.deprecated.empty() ) { members += " = "; auto enumIt = m_enums.find( member.type.type ); @@ -12301,7 +12493,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct if ( member.type.type != "VkStructureType" ) // filter out StructureType, which is supposed to be immutable ! { static const std::string templateString = R"( - ${constexpr}${structureName} & set${MemberName}( ${memberType} ${reference}${memberName}_ ) VULKAN_HPP_NOEXCEPT + ${deprecated}${constexpr}${structureName} & set${MemberName}( ${memberType} ${reference}${memberName}_ ) VULKAN_HPP_NOEXCEPT { ${assignment}; return *this; @@ -12314,18 +12506,26 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct : ( member.arraySizes.empty() ? member.type.compose( "Vk" ) : generateStandardArray( member.type.compose( "Vk" ), member.arraySizes ) ); const bool isReinterpretation = !member.bitCount.empty() && member.type.type.starts_with( "Vk" ); std::string assignment; - if ( isReinterpretation ) + if ( member.deprecated.empty() ) { - assignment = member.name + " = " + "*reinterpret_cast<" + member.type.type + "*>(&" + member.name + "_)"; + if ( isReinterpretation ) + { + assignment = member.name + " = " + "*reinterpret_cast<" + member.type.type + "*>(&" + member.name + "_)"; + } + else + { + assignment = member.name + " = " + member.name + "_"; + } } else { - assignment = member.name + " = " + member.name + "_"; + assignment = "detail::ignore( " + member.name + "_ )"; } str += replaceWithMap( templateString, { { "assignment", assignment }, { "constexpr", isReinterpretation ? "" : "VULKAN_HPP_CONSTEXPR_14 " }, + { "deprecated", member.deprecated.empty() ? "" : "VULKAN_HPP_DEPRECATED( \"" + member.deprecated + "\" ) " }, { "memberName", member.name }, { "MemberName", startUpperCase( member.name ) }, { "memberType", memberType }, @@ -12339,7 +12539,8 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct if ( member.lenExpressions[0] == "null-terminated" ) { - assert( member.lenMembers.empty() && ( member.lenExpressions.size() == 1 ) && ( member.arraySizes.size() == 1 ) && ( member.type.type == "char" ) ); + assert( member.deprecated.empty() && member.lenMembers.empty() && ( member.lenExpressions.size() == 1 ) && ( member.arraySizes.size() == 1 ) && + ( member.type.type == "char" ) ); static const std::string setStringTemplate = R"( #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) @@ -12365,7 +12566,7 @@ std::string VulkanHppGenerator::generateStructSetter( std::string const & struct else if ( ( structureName == "LayerSettingEXT" ) && ( index == 4 ) ) { // VkLayerSettingEXT::pValues needs some special handling! - assert( member.name == "pValues" ); + assert( member.deprecated.empty() && ( member.name == "pValues" ) ); static const std::string byTypeTemplate = R"( LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT { @@ -12446,12 +12647,25 @@ ${byString} if ( member.type.isPointer() ) { + std::string functionBody; + if ( member.deprecated.empty() ) + { + static const std::string functionBodyTemplate = R"( ${lenName} = ${lenValue}; + ${memberName} = ${arrayName}_.data();)"; + + functionBody = replaceWithMap( functionBodyTemplate, + { { "arrayName", arrayName }, { "lenName", lenName }, { "lenValue", lenValue }, { "memberName", member.name } } ); + } + else + { + functionBody = "detail::ignore( " + arrayName + "_ );"; + } + static const std::string setArrayTemplate = R"( #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ${templateHeader}${structureName} & set${ArrayName}( ArrayProxyNoTemporaries<${memberType}> const & ${arrayName}_ ) VULKAN_HPP_NOEXCEPT + ${deprecated}${templateHeader}${structureName} & set${ArrayName}( ArrayProxyNoTemporaries<${memberType}> const & ${arrayName}_ ) VULKAN_HPP_NOEXCEPT { - ${lenName} = ${lenValue}; - ${memberName} = ${arrayName}_.data(); + ${functionBody} return *this; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -12460,9 +12674,8 @@ ${byString} str += replaceWithMap( setArrayTemplate, { { "arrayName", arrayName }, { "ArrayName", startUpperCase( arrayName ) }, - { "lenName", lenName }, - { "lenValue", lenValue }, - { "memberName", member.name }, + { "deprecated", member.deprecated.empty() ? "" : "VULKAN_HPP_DEPRECATED( \"" + member.deprecated + "\" ) " }, + { "functionBody", functionBody }, { "memberType", memberType }, { "structureName", structureName }, { "templateHeader", templateHeader } } ); @@ -15723,10 +15936,9 @@ void VulkanHppGenerator::readStructMember( tinyxml2::XMLElement const * element, "member attribute holds unknown number of data: " + std::to_string( memberData.lenExpressions.size() ) ); memberData.lenMembers = filterNumbers( tokenizeAny( attribute.second, " /()+*" ) ); } - else if ( attribute.second == "deprecated" ) + else if ( attribute.first == "deprecated" ) { - assert( false ); - // the struct member is marked as deprecated/ignored, but still exisits -> no modifications needed here + memberData.deprecated = attribute.second; } else if ( attribute.first == "len" ) { diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 1cedfb5..757e604 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -400,6 +400,7 @@ private: std::string name = {}; std::vector arraySizes = {}; std::string bitCount = {}; + std::string deprecated = {}; std::vector lenExpressions = {}; std::vector> lenMembers = {}; bool noAutoValidity = {}; @@ -571,6 +572,7 @@ private: bool raii ) const; bool contains( std::vector const & enumValues, std::string const & name ) const; bool containsArray( std::string const & type ) const; + bool containsDeprecated( std::vector const & members ) const; bool containsFuncPointer( std::string const & type ) const; bool containsFloatingPoints( std::vector const & members ) const; bool containsUnion( std::string const & type ) const; @@ -780,7 +782,7 @@ private: bool definition, std::vector const & returnParamIndices, bool raii ) const; - std::string generateConstexprString( std::string const & structName ) const; + std::string generateConstexprString( std::pair const & structData ) const; std::string generateConstexprDefines() const; std::string generateConstexprUsings() const; std::string generateCppModuleFuncpointerUsings() const; @@ -1037,10 +1039,13 @@ private: std::string generateStaticAssertions() const; std::string generateStaticAssertions( std::vector const & requireData, std::string const & title, std::set & listedStructs ) const; std::string generateStruct( std::pair const & structure, std::set & listedStructs ) const; + std::string generateStructCastAssignments( std::pair const & structData ) const; std::string generateStructCompareOperators( std::pair const & structure ) const; std::string generateStructConstructors( std::pair const & structData ) const; std::string generateStructConstructorsEnhanced( std::pair const & structData ) const; std::string generateStructConstructorArgument( MemberData const & memberData, bool withDefault ) const; + std::string generateStructCopyAssignment( std::pair const & structData ) const; + std::string generateStructCopyConstructor( std::pair const & structData ) const; std::string generateStructHashStructure( std::pair const & structure, std::set & listedStructs ) const; std::string generateStructHashStructures() const; std::string generateStructHashSum( std::string const & structName, std::vector const & members ) const; diff --git a/snippets/ResultValue.hpp b/snippets/ResultValue.hpp index d111bb3..5a3a6dd 100644 --- a/snippets/ResultValue.hpp +++ b/snippets/ResultValue.hpp @@ -141,8 +141,9 @@ namespace detail { template - void ignore( T const & ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT { + return true; } VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) diff --git a/snippets/macros.hpp b/snippets/macros.hpp index 1c831d3..5f11ae1 100644 --- a/snippets/macros.hpp +++ b/snippets/macros.hpp @@ -141,6 +141,11 @@ ${vulkan_64_bit_ptr_defines} # else # define VULKAN_HPP_CONSTEXPR_14 # endif +# if 201603 <= __cpp_constexpr +# define VULKAN_HPP_CONSTEXPR_17 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_17 +# endif # if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) ) # define VULKAN_HPP_CONSTEXPR_20 constexpr # else diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index 91d79ad..135b684 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -472,7 +472,7 @@ namespace VULKAN_HPP_NAMESPACE typename std::enable_if().begin() ), T *>::value && std::is_convertible().size() ), std::size_t>::value && std::is_lvalue_reference::value, int>::type = 0> - ArrayProxyNoTemporaries( V & v ) VULKAN_HPP_NOEXCEPT + ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT : m_count( static_cast( v.size() ) ) , m_ptr( v.begin() ) { @@ -7360,8 +7360,9 @@ namespace VULKAN_HPP_NAMESPACE namespace detail { template - void ignore( T const & ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT { + return true; } VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) diff --git a/vulkan/vulkan_hash.hpp b/vulkan/vulkan_hash.hpp index ee22504..33c4645 100644 --- a/vulkan/vulkan_hash.hpp +++ b/vulkan/vulkan_hash.hpp @@ -4393,14 +4393,6 @@ namespace std VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount ); - for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i ) - { - for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - } VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) { diff --git a/vulkan/vulkan_hpp_macros.hpp b/vulkan/vulkan_hpp_macros.hpp index db71e44..5bf0fa7 100644 --- a/vulkan/vulkan_hpp_macros.hpp +++ b/vulkan/vulkan_hpp_macros.hpp @@ -158,6 +158,11 @@ # else # define VULKAN_HPP_CONSTEXPR_14 # endif +# if 201603 <= __cpp_constexpr +# define VULKAN_HPP_CONSTEXPR_17 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_17 +# endif # if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) ) # define VULKAN_HPP_CONSTEXPR_20 constexpr # else diff --git a/vulkan/vulkan_structs.hpp b/vulkan/vulkan_structs.hpp index 6480a9f..c3f3b84 100644 --- a/vulkan/vulkan_structs.hpp +++ b/vulkan/vulkan_structs.hpp @@ -35995,28 +35995,48 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo; #if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateFlags flags_ = {}, - uint32_t queueCreateInfoCount_ = {}, - const DeviceQueueCreateInfo * pQueueCreateInfos_ = {}, - uint32_t enabledLayerCount_ = {}, - const char * const * ppEnabledLayerNames_ = {}, - uint32_t enabledExtensionCount_ = {}, - const char * const * ppEnabledExtensionNames_ = {}, - const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + +# if defined( _MSC_VER ) +// no need to ignore this warning with MSVC +# elif defined( __clang__ ) +// no need to ignore this warning with clang +# elif defined( __GNUC__ ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# else +// unknown compiler... just ignore the warnings for yourselves ;) +# endif + VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateFlags flags_ = {}, + uint32_t queueCreateInfoCount_ = {}, + const DeviceQueueCreateInfo * pQueueCreateInfos_ = {}, + uint32_t enabledLayerCount_ = {}, + const char * const * ppEnabledLayerNames_ = {}, + uint32_t enabledExtensionCount_ = {}, + const char * const * ppEnabledExtensionNames_ = {}, + const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } , flags{ flags_ } , queueCreateInfoCount{ queueCreateInfoCount_ } , pQueueCreateInfos{ pQueueCreateInfos_ } - , enabledLayerCount{ enabledLayerCount_ } - , ppEnabledLayerNames{ ppEnabledLayerNames_ } , enabledExtensionCount{ enabledExtensionCount_ } , ppEnabledExtensionNames{ ppEnabledExtensionNames_ } , pEnabledFeatures{ pEnabledFeatures_ } { + detail::ignore( enabledLayerCount_ ); + detail::ignore( ppEnabledLayerNames_ ); } - VULKAN_HPP_CONSTEXPR DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : pNext{ rhs.pNext } + , flags{ rhs.flags } + , queueCreateInfoCount{ rhs.queueCreateInfoCount } + , pQueueCreateInfos{ rhs.pQueueCreateInfos } + , enabledExtensionCount{ rhs.enabledExtensionCount } + , ppEnabledExtensionNames{ rhs.ppEnabledExtensionNames } + , pEnabledFeatures{ rhs.pEnabledFeatures } + { + } DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceCreateInfo( *reinterpret_cast( &rhs ) ) {} @@ -36031,21 +36051,49 @@ namespace VULKAN_HPP_NAMESPACE , flags( flags_ ) , queueCreateInfoCount( static_cast( queueCreateInfos_.size() ) ) , pQueueCreateInfos( queueCreateInfos_.data() ) - , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) - , ppEnabledLayerNames( pEnabledLayerNames_.data() ) , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) , pEnabledFeatures( pEnabledFeatures_ ) { + detail::ignore( pEnabledLayerNames_ ); } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# if defined( _MSC_VER ) +// no need to ignore this warning with MSVC +# elif defined( __clang__ ) +// no need to ignore this warning with clang +# elif defined( __GNUC__ ) +# pragma GCC diagnostic pop +# else +// unknown compiler... just ignore the warnings for yourselves ;) +# endif + + DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + pNext = rhs.pNext; + flags = rhs.flags; + queueCreateInfoCount = rhs.queueCreateInfoCount; + pQueueCreateInfos = rhs.pQueueCreateInfos; + enabledExtensionCount = rhs.enabledExtensionCount; + ppEnabledExtensionNames = rhs.ppEnabledExtensionNames; + pEnabledFeatures = rhs.pEnabledFeatures; + } + return *this; + } #endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ DeviceCreateInfo & operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT { - *this = *reinterpret_cast( &rhs ); + pNext = rhs.pNext; + flags = static_cast( rhs.flags ); + queueCreateInfoCount = rhs.queueCreateInfoCount; + pQueueCreateInfos = reinterpret_cast( rhs.pQueueCreateInfos ); + enabledExtensionCount = rhs.enabledExtensionCount; + ppEnabledExtensionNames = rhs.ppEnabledExtensionNames; + pEnabledFeatures = reinterpret_cast( rhs.pEnabledFeatures ); return *this; } @@ -36083,23 +36131,24 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) VULKAN_HPP_NOEXCEPT + VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) VULKAN_HPP_NOEXCEPT { - enabledLayerCount = enabledLayerCount_; + detail::ignore( enabledLayerCount_ ); return *this; } + VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT { - ppEnabledLayerNames = ppEnabledLayerNames_; + detail::ignore( ppEnabledLayerNames_ ); return *this; } # if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VULKAN_HPP_DEPRECATED( "ignored" ) DeviceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT { - enabledLayerCount = static_cast( pEnabledLayerNames_.size() ); - ppEnabledLayerNames = pEnabledLayerNames_.data(); + detail::ignore( pEnabledLayerNames_ ); return *this; } # endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -36195,14 +36244,6 @@ namespace VULKAN_HPP_NAMESPACE return cmp; if ( auto cmp = pQueueCreateInfos <=> rhs.pQueueCreateInfos; cmp != 0 ) return cmp; - if ( auto cmp = enabledLayerCount <=> rhs.enabledLayerCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < enabledLayerCount; ++i ) - { - if ( ppEnabledLayerNames[i] != rhs.ppEnabledLayerNames[i] ) - if ( auto cmp = strcmp( ppEnabledLayerNames[i], rhs.ppEnabledLayerNames[i] ); cmp != 0 ) - return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; - } if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 ) return cmp; for ( size_t i = 0; i < enabledExtensionCount; ++i ) @@ -36221,12 +36262,7 @@ namespace VULKAN_HPP_NAMESPACE bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && - ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledLayerCount == rhs.enabledLayerCount ) && - std::equal( ppEnabledLayerNames, - ppEnabledLayerNames + enabledLayerCount, - rhs.ppEnabledLayerNames, - []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) && - ( enabledExtensionCount == rhs.enabledExtensionCount ) && + ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledExtensionCount == rhs.enabledExtensionCount ) && std::equal( ppEnabledExtensionNames, ppEnabledExtensionNames + enabledExtensionCount, rhs.ppEnabledExtensionNames, @@ -36240,13 +36276,13 @@ namespace VULKAN_HPP_NAMESPACE } public: - StructureType sType = StructureType::eDeviceCreateInfo; - const void * pNext = {}; - DeviceCreateFlags flags = {}; - uint32_t queueCreateInfoCount = {}; - const DeviceQueueCreateInfo * pQueueCreateInfos = {}; - uint32_t enabledLayerCount = {}; - const char * const * ppEnabledLayerNames = {}; + StructureType sType = StructureType::eDeviceCreateInfo; + const void * pNext = {}; + DeviceCreateFlags flags = {}; + uint32_t queueCreateInfoCount = {}; + const DeviceQueueCreateInfo * pQueueCreateInfos = {}; + VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount; + VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames; uint32_t enabledExtensionCount = {}; const char * const * ppEnabledExtensionNames = {}; const PhysicalDeviceFeatures * pEnabledFeatures = {};