From d9bb97d9ec324ecd563236280f7683a2837e76b2 Mon Sep 17 00:00:00 2001 From: asuessenbach Date: Tue, 13 Apr 2021 12:25:10 +0200 Subject: [PATCH] Correct enum values for AccessFlagBits2KHR and PipelineStageFlagBits2KHR. All those values erroneously started with "e2", instead of just "e". --- VulkanHppGenerator.cpp | 629 +++++++++++++++++++-------------------- VulkanHppGenerator.hpp | 4 +- vulkan/vulkan.hpp | 646 ++++++++++++++++++++--------------------- 3 files changed, 644 insertions(+), 635 deletions(-) diff --git a/VulkanHppGenerator.cpp b/VulkanHppGenerator.cpp index d217874..5f67f9c 100644 --- a/VulkanHppGenerator.cpp +++ b/VulkanHppGenerator.cpp @@ -405,13 +405,15 @@ std::set determineSkippedParams( size_t returnParamIndex, std::map skippedParams; // the size-parameters of vector parameters are not explicitly used in the enhanced API - std::for_each( - vectorParamIndices.begin(), vectorParamIndices.end(), [&skippedParams]( std::pair const & vp ) { - if ( vp.second != INVALID_INDEX ) - { - skippedParams.insert( vp.second ); - } - } ); + std::for_each( vectorParamIndices.begin(), + vectorParamIndices.end(), + [&skippedParams]( std::pair const & vp ) + { + if ( vp.second != INVALID_INDEX ) + { + skippedParams.insert( vp.second ); + } + } ); // and the return parameter is also skipped if ( returnParamIndex != INVALID_INDEX ) @@ -475,29 +477,6 @@ std::string getEnumPostfix( std::string const & name, std::set cons return postfix; } -std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) -{ - std::string prefix; - if ( name == "VkResult" ) - { - prefix = "VK_"; - } - else if ( bitmask ) - { - // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case - // end that with "Bit" - size_t pos = name.find( "FlagBits" ); - check( pos != std::string::npos, line, "bitmask <" + name + "> does not contain " ); - prefix = toUpperCase( name.substr( 0, pos ) ) + "_"; - } - else - { - // for a non-bitmask enum, convert the name to upper case - prefix = toUpperCase( name ) + "_"; - } - return prefix; -} - std::string extractTag( int line, std::string const & name, std::set const & tags ) { // extract the tag from the name, which is supposed to look like VK__ @@ -726,23 +705,18 @@ std::string toString( std::vector const & strings ) std::string toUpperCase( std::string const & name ) { std::string convertedName; - convertedName.reserve( name.size() ); - - bool lowerOrDigit = false; + bool previousIsLowerCase = false; + bool previousIsDigit = false; for ( auto c : name ) { - if ( islower( c ) || isdigit( c ) ) - { - lowerOrDigit = true; - } - else if ( lowerOrDigit ) + if ( ( isupper( c ) && ( previousIsLowerCase || previousIsDigit ) ) || ( isdigit( c ) && !previousIsDigit ) ) { convertedName.push_back( '_' ); - lowerOrDigit = false; } convertedName.push_back( static_cast( toupper( c ) ) ); + previousIsLowerCase = !!islower( c ); + previousIsDigit = !!isdigit( c ); } - return convertedName; } @@ -873,9 +847,9 @@ void VulkanHppGenerator::appendArguments( std::string & str, } else { - it = find_if( vectorParamIndices.begin(), vectorParamIndices.end(), [i]( std::pair const & vpi ) { - return vpi.second == i; - } ); + it = find_if( vectorParamIndices.begin(), + vectorParamIndices.end(), + [i]( std::pair const & vpi ) { return vpi.second == i; } ); if ( it != vectorParamIndices.end() ) { appendArgumentCount( str, it->first, commandData.params[it->first].name, templateParamIndex ); @@ -1355,49 +1329,49 @@ void VulkanHppGenerator::appendCommand( std::string & str, } break; case 1: - { - // two returns but just one vector - auto vectorParamIndexIt = vectorParamIndices.begin(); - if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && - ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) ) { - // the size is a return value as well -> enumerate the values - // and the vector data is not of type void - if ( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) ) + // two returns but just one vector + auto vectorParamIndexIt = vectorParamIndices.begin(); + if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && + ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) ) { - // provide standard, enhanced, and vector calls - appendCommandVector( str, - name, - commandData, - initialSkipCount, - definition, - *vectorParamIndexIt, - nonConstPointerParamIndices ); + // the size is a return value as well -> enumerate the values + // and the vector data is not of type void + if ( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) ) + { + // provide standard, enhanced, and vector calls + appendCommandVector( str, + name, + commandData, + initialSkipCount, + definition, + *vectorParamIndexIt, + nonConstPointerParamIndices ); + appendedFunction = true; + } + } + } + break; + case 2: + { + // two returns and two vectors! But one input vector, one output vector of the same size, and one + // output value + if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) && + ( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ) && + ( commandData.returnType == "VkResult" ) ) + { + // provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls + appendCommandStandardEnhancedDeprecatedAllocator( str, + name, + commandData, + initialSkipCount, + definition, + vectorParamIndices, + nonConstPointerParamIndices ); appendedFunction = true; } } - } - break; - case 2: - { - // two returns and two vectors! But one input vector, one output vector of the same size, and one output - // value - if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) && - ( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() ) && - ( commandData.returnType == "VkResult" ) ) - { - // provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls - appendCommandStandardEnhancedDeprecatedAllocator( str, - name, - commandData, - initialSkipCount, - definition, - vectorParamIndices, - nonConstPointerParamIndices ); - appendedFunction = true; - } - } - break; + break; } } } @@ -2489,9 +2463,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pairfirst; } @@ -2524,10 +2499,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pairsecond.values.begin(), enumIt->second.values.end(), [&handleData]( EnumValueData const & evd ) { - return evd.vulkanValue == handleData.second.objTypeEnum; - } ); + valueIt = std::find_if( enumIt->second.values.begin(), + enumIt->second.values.end(), + [&handleData]( EnumValueData const & evd ) + { return evd.vulkanValue == handleData.second.objTypeEnum; } ); assert( valueIt != enumIt->second.values.end() ); str += replaceWithMap( templateString, @@ -3483,9 +3458,9 @@ void VulkanHppGenerator::appendRAIIHandle( std::string & auto enumIt = m_enums.find( "VkObjectType" ); assert( enumIt != m_enums.end() ); auto valueIt = - std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), [&handle]( EnumValueData const & evd ) { - return evd.vulkanValue == handle.second.objTypeEnum; - } ); + std::find_if( enumIt->second.values.begin(), + enumIt->second.values.end(), + [&handle]( EnumValueData const & evd ) { return evd.vulkanValue == handle.second.objTypeEnum; } ); assert( valueIt != enumIt->second.values.end() ); std::string objTypeEnum = valueIt->vkValue; @@ -3756,7 +3731,8 @@ bool VulkanHppGenerator::checkEquivalentSingularConstructor( auto singularCommandIt = std::find_if( constructorIts.begin(), constructorIts.end(), - [constructorIt, lenIt]( std::map::const_iterator it ) { + [constructorIt, lenIt]( std::map::const_iterator it ) + { if ( it->second.params.size() + 1 != constructorIt->second.params.size() ) { return false; @@ -4030,8 +4006,8 @@ std::string VulkanHppGenerator::constructCallArgumentEnhanced( std::vector deleter( *this, allocator, d )"; break; case 2: - { - auto vpiIt = vectorParamIndices.find( returnParamIndex ); - assert( vpiIt != vectorParamIndices.end() ); - std::string poolType, poolName; - std::tie( poolType, poolName ) = getPoolTypeAndName( commandData.params[vpiIt->second].type.type ); - assert( !poolType.empty() ); - poolType = stripPrefix( poolType, "Vk" ); - poolName = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + poolName; + { + auto vpiIt = vectorParamIndices.find( returnParamIndex ); + assert( vpiIt != vectorParamIndices.end() ); + std::string poolType, poolName; + std::tie( poolType, poolName ) = getPoolTypeAndName( commandData.params[vpiIt->second].type.type ); + assert( !poolType.empty() ); + poolType = stripPrefix( poolType, "Vk" ); + poolName = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + poolName; - deleterDefinition = - "PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )"; - } - break; + deleterDefinition = + "PoolFree<" + className + ", " + poolType + ", Dispatch> deleter( *this, " + poolName + ", d )"; + } + break; } std::string typenameCheck = @@ -6675,9 +6651,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st assert( typeIt->len == param.name ); continue; } - else if ( std::find_if( params.begin(), params.end(), [¶m]( ParamData const & pd ) { - return pd.len == param.name; - } ) != params.end() ) + else if ( std::find_if( params.begin(), + params.end(), + [¶m]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() ) { // this is the len of an other parameter, which will be mapped to an ArrayProxy assert( param.type.isValue() && ( param.type.type == "uint32_t" ) ); @@ -6705,9 +6681,9 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorArguments( std::st } else { - assert( std::find_if( params.begin(), params.end(), [¶m]( ParamData const & pd ) { - return pd.name == param.len; - } ) != params.end() ); + assert( std::find_if( params.begin(), + params.end(), + [¶m]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ); if ( singular ) { arguments += argumentType + " const & " + stripPluralS( argumentName ); @@ -6902,10 +6878,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList assert( destructorParam.type.isValue() && destructorParam.arraySizes.empty() && destructorParam.len.empty() && !destructorParam.optional ); initializationList += "m_" + startLowerCase( stripPrefix( destructorParam.type.type, "Vk" ) ) + "( "; - auto constructorParamIt = std::find_if( - constructorIt->second.params.begin(), - constructorIt->second.params.end(), - [&destructorParam]( ParamData const & pd ) { return pd.type.type == destructorParam.type.type; } ); + auto constructorParamIt = std::find_if( constructorIt->second.params.begin(), + constructorIt->second.params.end(), + [&destructorParam]( ParamData const & pd ) + { return pd.type.type == destructorParam.type.type; } ); if ( constructorParamIt != constructorIt->second.params.end() ) { assert( constructorParamIt->type.isValue() && constructorParamIt->arraySizes.empty() && @@ -6922,10 +6898,10 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorInitializationList auto structureIt = m_structures.find( constructorParam.type.type ); if ( structureIt != m_structures.end() ) { - auto structureMemberIt = std::find_if( - structureIt->second.members.begin(), - structureIt->second.members.end(), - [&destructorParam]( MemberData const & md ) { return md.type.type == destructorParam.type.type; } ); + auto structureMemberIt = std::find_if( structureIt->second.members.begin(), + structureIt->second.members.end(), + [&destructorParam]( MemberData const & md ) + { return md.type.type == destructorParam.type.type; } ); if ( structureMemberIt != structureIt->second.members.end() ) { assert( constructorParam.type.isConstPointer() && constructorParam.arraySizes.empty() && @@ -7147,8 +7123,8 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorVector( assert( structureIt != m_structures.end() ); assert( std::find_if( structureIt->second.members.begin(), structureIt->second.members.end(), - [&lenParts]( MemberData const & md ) { return md.name == lenParts[1]; } ) != - structureIt->second.members.end() ); + [&lenParts]( MemberData const & md ) + { return md.name == lenParts[1]; } ) != structureIt->second.members.end() ); assert( constructorIt->second.successCodes.size() == 1 ); vectorSize = startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + lenParts[1]; } @@ -7156,9 +7132,8 @@ std::string VulkanHppGenerator::constructRAIIHandleConstructorVector( { auto arrayIt = std::find_if( constructorIt->second.params.begin(), constructorIt->second.params.end(), - [&lenIt, &handleParamIt]( ParamData const & pd ) { - return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name ); - } ); + [&lenIt, &handleParamIt]( ParamData const & pd ) + { return ( pd.len == lenIt->name ) && ( pd.name != handleParamIt->name ); } ); assert( arrayIt != constructorIt->second.params.end() ); vectorSize = startLowerCase( stripPrefix( arrayIt->name, "p" ) ) + ".size()"; } @@ -7357,9 +7332,10 @@ std::string else { assert( param.type.isConstPointer() ); - assert( !param.len.empty() && ( std::find_if( params.begin(), params.end(), [¶m]( ParamData const & pd ) { - return pd.name == param.len; - } ) != params.end() ) ); + assert( !param.len.empty() && + ( std::find_if( params.begin(), + params.end(), + [¶m]( ParamData const & pd ) { return pd.name == param.len; } ) != params.end() ) ); arguments += "reinterpret_cast<" + param.type.type + " const *>( &" + argument + " )"; } } @@ -7367,9 +7343,9 @@ std::string { assert( ( param.type.type == "uint32_t" ) && param.type.isValue() && param.arraySizes.empty() && param.len.empty() && !param.optional ); - assert( std::find_if( params.begin(), params.end(), [¶m]( ParamData const & pd ) { - return pd.len == param.name; - } ) != params.end() ); + assert( std::find_if( params.begin(), + params.end(), + [¶m]( ParamData const & pd ) { return pd.len == param.name; } ) != params.end() ); arguments += "1"; } encounteredArgument = true; @@ -8909,41 +8885,41 @@ void VulkanHppGenerator::constructRAIIHandleMemberFunction( std::string & } break; case 1: - { - // two returns but just one vector - auto vectorParamIndexIt = vectorParamIndices.begin(); - if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && - ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) ) { - // the size is a return value as well -> enumerate the values - if ( commandIt->second.returnType == "VkResult" ) + // two returns but just one vector + auto vectorParamIndexIt = vectorParamIndices.begin(); + if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) && + ( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) ) { - // as the returnType is "VkResult", there has to be at least one success code - assert( !commandIt->second.successCodes.empty() ); - if ( !commandIt->second.errorCodes.empty() ) + // the size is a return value as well -> enumerate the values + if ( commandIt->second.returnType == "VkResult" ) { - if ( ( commandIt->second.successCodes.size() == 2 ) && - ( commandIt->second.successCodes[0] == "VK_SUCCESS" ) && - ( commandIt->second.successCodes[1] == "VK_INCOMPLETE" ) ) + // as the returnType is "VkResult", there has to be at least one success code + assert( !commandIt->second.successCodes.empty() ); + if ( !commandIt->second.errorCodes.empty() ) { - std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultEnumerate( + if ( ( commandIt->second.successCodes.size() == 2 ) && + ( commandIt->second.successCodes[0] == "VK_SUCCESS" ) && + ( commandIt->second.successCodes[1] == "VK_INCOMPLETE" ) ) + { + std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionResultEnumerate( + commandIt, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices ); + commandConstructed = true; + } + } + } + else + { + if ( commandIt->second.returnType == "void" ) + { + std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionVoidEnumerate( commandIt, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices ); commandConstructed = true; } } } - else - { - if ( commandIt->second.returnType == "void" ) - { - std::tie( declaration, definition ) = constructRAIIHandleMemberFunctionVoidEnumerate( - commandIt, initialSkipCount, vectorParamIndices, nonConstPointerParamIndices ); - commandConstructed = true; - } - } } - } - break; + break; case 2: // two returns and two vectors if ( ( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() ) && @@ -9677,10 +9653,10 @@ std::string VulkanHppGenerator::constructRAIIHandleSingularConstructorArguments( auto structureIt = m_structures.find( constructorParam.type.type ); if ( structureIt != m_structures.end() ) { - auto memberIt = std::find_if( - structureIt->second.members.begin(), - structureIt->second.members.end(), - [&destructorParam]( MemberData const & md ) { return md.type.type == destructorParam.type.type; } ); + auto memberIt = std::find_if( structureIt->second.members.begin(), + structureIt->second.members.end(), + [&destructorParam]( MemberData const & md ) + { return md.type.type == destructorParam.type.type; } ); if ( memberIt != structureIt->second.members.end() ) { #if !defined( NDEBUG ) @@ -9970,10 +9946,10 @@ void VulkanHppGenerator::appendStructConstructorsEnhanced( std::string & std::pair const & structData, std::string const & prefix ) const { - auto memberIts = - findAll( structData.second.members.begin(), structData.second.members.end(), []( MemberData const & md ) { - return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() ); - } ); + auto memberIts = findAll( structData.second.members.begin(), + structData.second.members.end(), + []( MemberData const & md ) + { return !md.len.empty() && ( ignoreLens.find( md.len.front() ) == ignoreLens.end() ); } ); if ( !memberIts.empty() ) { // maximal one member to be handled by an ArrayProxyNoTemporaries is of type void @@ -10450,9 +10426,10 @@ void VulkanHppGenerator::appendStructureChainValidation( std::string & str ) if ( itExtend == m_structures.end() ) { // look if the extendName acutally is an alias of some other structure - itExtend = std::find_if( m_structures.begin(), m_structures.end(), [extendName]( auto const & sd ) { - return sd.second.aliases.find( extendName ) != sd.second.aliases.end(); - } ); + itExtend = std::find_if( m_structures.begin(), + m_structures.end(), + [extendName]( auto const & sd ) + { return sd.second.aliases.find( extendName ) != sd.second.aliases.end(); } ); } if ( itExtend == m_structures.end() ) { @@ -10534,48 +10511,48 @@ void VulkanHppGenerator::appendType( std::string & str, std::string const & type switch ( typeIt->second.category ) { case TypeCategory::Handle: - { - auto handleIt = m_handles.find( typeName ); - if ( handleIt == m_handles.end() ) { - handleIt = std::find_if( - m_handles.begin(), m_handles.end(), [&typeName]( std::pair const & hd ) { - return hd.second.alias == typeName; - } ); - assert( handleIt != m_handles.end() ); - if ( m_listedTypes.find( handleIt->first ) == m_listedTypes.end() ) + auto handleIt = m_handles.find( typeName ); + if ( handleIt == m_handles.end() ) + { + handleIt = std::find_if( m_handles.begin(), + m_handles.end(), + [&typeName]( std::pair const & hd ) + { return hd.second.alias == typeName; } ); + assert( handleIt != m_handles.end() ); + if ( m_listedTypes.find( handleIt->first ) == m_listedTypes.end() ) + { + appendHandle( str, *handleIt ); + } + } + else { appendHandle( str, *handleIt ); } } - else - { - appendHandle( str, *handleIt ); - } - } - break; + break; case TypeCategory::Struct: case TypeCategory::Union: - { - auto structIt = m_structures.find( typeName ); - if ( structIt == m_structures.end() ) { - structIt = std::find_if( - m_structures.begin(), m_structures.end(), [&typeName]( std::pair const & sd ) { - return sd.second.aliases.find( typeName ) != sd.second.aliases.end(); - } ); - assert( structIt != m_structures.end() ); - if ( m_listedTypes.find( structIt->first ) == m_listedTypes.end() ) + auto structIt = m_structures.find( typeName ); + if ( structIt == m_structures.end() ) + { + structIt = std::find_if( m_structures.begin(), + m_structures.end(), + [&typeName]( std::pair const & sd ) + { return sd.second.aliases.find( typeName ) != sd.second.aliases.end(); } ); + assert( structIt != m_structures.end() ); + if ( m_listedTypes.find( structIt->first ) == m_listedTypes.end() ) + { + appendStruct( str, *structIt ); + } + } + else { appendStruct( str, *structIt ); } } - else - { - appendStruct( str, *structIt ); - } - } - break; + break; default: m_listedTypes.insert( typeIt->first ); break; } } @@ -10605,7 +10582,8 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair" ); @@ -10757,9 +10736,8 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line, // only list aliases that map to different vkNames aliasIt = std::find_if( aliases.begin(), aliases.end(), - [&vkName]( std::pair> const & aliasEntry ) { - return vkName == aliasEntry.second.second; - } ); + [&vkName]( std::pair> const & aliasEntry ) + { return vkName == aliasEntry.second.second; } ); if ( aliasIt == aliases.end() ) { aliases.insert( std::make_pair( name, std::make_pair( aliasName, vkName ) ) ); @@ -10777,9 +10755,9 @@ void VulkanHppGenerator::EnumData::addEnumValue( int line, { std::string translatedName = createEnumValueName( valueName, prefix, postfix, bitmask, tag ); - auto it = std::find_if( values.begin(), values.end(), [&translatedName]( EnumValueData const & evd ) { - return evd.vkValue == translatedName; - } ); + auto it = std::find_if( values.begin(), + values.end(), + [&translatedName]( EnumValueData const & evd ) { return evd.vkValue == translatedName; } ); if ( it == values.end() ) { values.emplace_back( line, valueName, translatedName, extension, bitpos ); @@ -10929,9 +10907,8 @@ void VulkanHppGenerator::checkCorrectness() { check( std::find_if( m_handles.begin(), m_handles.end(), - [&objectTypeValue]( std::pair const & hd ) { - return hd.second.objTypeEnum == objectTypeValue.vulkanValue; - } ) != m_handles.end(), + [&objectTypeValue]( std::pair const & hd ) + { return hd.second.objTypeEnum == objectTypeValue.vulkanValue; } ) != m_handles.end(), objectTypeValue.xmlLine, "VkObjectType value <" + objectTypeValue.vulkanValue + "> not specified as \"objtypeenum\" for any handle" ); @@ -10966,8 +10943,8 @@ void VulkanHppGenerator::checkCorrectness() std::string const & selection = data.selection; check( std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), - [&selection]( EnumValueData const & evd ) { return evd.vulkanValue == selection; } ) != - enumIt->second.values.end(), + [&selection]( EnumValueData const & evd ) + { return evd.vulkanValue == selection; } ) != enumIt->second.values.end(), data.xmlLine, "union member <" + data.name + "> uses selection <" + selection + "> that is not part of the selector type <" + selectorIt->type.type + ">" ); @@ -10991,8 +10968,8 @@ void VulkanHppGenerator::checkCorrectness() { check( std::find_if( enumIt->second.values.begin(), enumIt->second.values.end(), - [&enumValue]( auto const & evd ) { return enumValue == evd.vulkanValue; } ) != - enumIt->second.values.end(), + [&enumValue]( auto const & evd ) + { return enumValue == evd.vulkanValue; } ) != enumIt->second.values.end(), member.xmlLine, "value <" + enumValue + "> for member <" + member.name + "> in structure <" + structure.first + " of enum type <" + member.type.type + "> not listed" ); @@ -11126,11 +11103,16 @@ std::vector::const_iterat for ( auto commandIt = m_commands.begin(); commandIt != m_commands.end(); ) { commandIt = - std::find_if( commandIt, m_commands.end(), [&handleType]( std::pair const & cd ) { - return std::find_if( cd.second.params.begin(), cd.second.params.end(), [&handleType]( ParamData const & pd ) { - return ( pd.type.type == handleType ) && pd.type.isNonConstPointer(); - } ) != cd.second.params.end(); - } ); + std::find_if( commandIt, + m_commands.end(), + [&handleType]( std::pair const & cd ) + { + return std::find_if( cd.second.params.begin(), + cd.second.params.end(), + [&handleType]( ParamData const & pd ) { + return ( pd.type.type == handleType ) && pd.type.isNonConstPointer(); + } ) != cd.second.params.end(); + } ); if ( commandIt != m_commands.end() ) { // only commands that provide all information needed for the destructor can be considered a constructor! @@ -11143,11 +11125,11 @@ std::vector::const_iterat assert( paramIt != destructorIt->second.params.end() ); for ( auto pit = destructorIt->second.params.begin(); valid && pit != destructorIt->second.params.end(); ++pit ) { - valid = ( pit->name == paramIt->len ) || - ( std::find_if( - commandIt->second.params.begin(), commandIt->second.params.end(), [&pit]( ParamData const & pd ) { - return pd.type.type == pit->type.type; - } ) != commandIt->second.params.end() ); + valid = ( pit->name == paramIt->len ) || ( std::find_if( commandIt->second.params.begin(), + commandIt->second.params.end(), + [&pit]( ParamData const & pd ) { + return pd.type.type == pit->type.type; + } ) != commandIt->second.params.end() ); for ( auto cit = commandIt->second.params.begin(); !valid && cit != commandIt->second.params.end(); ++cit ) { auto structureIt = m_structures.find( cit->type.type ); @@ -11155,8 +11137,8 @@ std::vector::const_iterat { valid = std::find_if( structureIt->second.members.begin(), structureIt->second.members.end(), - [&pit]( MemberData const & md ) { return md.type.type == pit->type.type; } ) != - structureIt->second.members.end(); + [&pit]( MemberData const & md ) + { return md.type.type == pit->type.type; } ) != structureIt->second.members.end(); } } } @@ -11232,10 +11214,10 @@ size_t VulkanHppGenerator::determineReturnParamIndex( CommandData const & { // it's a non-const pointer // assert that it's not a vector-size parameter - assert( std::find_if( - vectorParamIndices.begin(), vectorParamIndices.end(), [index]( std::pair const & vpi ) { - return vpi.second == index; - } ) == vectorParamIndices.end() ); + assert( std::find_if( vectorParamIndices.begin(), + vectorParamIndices.end(), + [index]( std::pair const & vpi ) + { return vpi.second == index; } ) == vectorParamIndices.end() ); std::map::const_iterator vpit = vectorParamIndices.find( index ); if ( ( vpit == vectorParamIndices.end() ) || twoStep || ( vectorParamIndices.size() > 1 ) || @@ -11350,9 +11332,10 @@ std::map { if ( !it->len.empty() ) { - auto findIt = std::find_if( params.begin(), it, [this, &it]( ParamData const & pd ) { - return ( pd.name == it->len ) || isLenByStructMember( it->len, pd ); - } ); + auto findIt = std::find_if( params.begin(), + it, + [this, &it]( ParamData const & pd ) + { return ( pd.name == it->len ) || isLenByStructMember( it->len, pd ); } ); if ( findIt < it ) { @@ -11646,6 +11629,32 @@ std::string return sizeCheck; } +std::string VulkanHppGenerator::getEnumPrefix( int line, std::string const & name, bool bitmask ) const +{ + std::string prefix; + if ( name == "VkResult" ) + { + prefix = "VK_"; + } + else if ( bitmask ) + { + // for a bitmask enum, start with "VK", cut off the trailing "FlagBits", and convert that name to upper case + // end that with "Bit" + size_t pos = name.find( "FlagBits" ); + check( pos != std::string::npos, line, "bitmask <" + name + "> does not contain " ); + std::string shortenedName = name; + shortenedName.erase( pos, strlen( "FlagBits" ) ); + std::string tag = findTag( m_tags, shortenedName ); + prefix = toUpperCase( stripPostfix( shortenedName, tag ) ) + "_"; + } + else + { + // for a non-bitmask enum, convert the name to upper case + prefix = toUpperCase( name ) + "_"; + } + return prefix; +} + std::set VulkanHppGenerator::getPlatforms( std::set const & extensions ) const { std::set platforms; @@ -11666,9 +11675,10 @@ std::pair VulkanHppGenerator::getPoolTypeAndName( std: structIt->second.members.end(), []( MemberData const & md ) { return md.name.find( "Pool" ) != std::string::npos; } ); assert( memberIt != structIt->second.members.end() ); - assert( std::find_if( std::next( memberIt ), structIt->second.members.end(), []( MemberData const & md ) { - return md.name.find( "Pool" ) != std::string::npos; - } ) == structIt->second.members.end() ); + assert( std::find_if( std::next( memberIt ), + structIt->second.members.end(), + []( MemberData const & md ) + { return md.name.find( "Pool" ) != std::string::npos; } ) == structIt->second.members.end() ); return std::make_pair( memberIt->type.type, memberIt->name ); } @@ -11680,21 +11690,21 @@ std::string VulkanHppGenerator::getVectorSize( std::vector const & switch ( lenParts.size() ) { case 1: - { - std::string const & len = lenParts[0]; - size_t lenIdx = std::distance( - params.begin(), - std::find_if( params.begin(), params.end(), [&len]( ParamData const & pd ) { return pd.name == len; } ) ); - assert( lenIdx < params.size() ); - auto lenVectorParamIt = - std::find_if( vectorParamIndices.begin(), - vectorParamIndices.end(), - [&lenIdx]( std::pair const & vpi ) { return vpi.second == lenIdx; } ); - return ( lenVectorParamIt == vectorParamIndices.end() ) - ? lenParts[0] - : ( startLowerCase( stripPrefix( params[lenVectorParamIt->first].name, "p" ) ) + ".size()" ); - } - break; + { + std::string const & len = lenParts[0]; + size_t lenIdx = std::distance( + params.begin(), + std::find_if( params.begin(), params.end(), [&len]( ParamData const & pd ) { return pd.name == len; } ) ); + assert( lenIdx < params.size() ); + auto lenVectorParamIt = + std::find_if( vectorParamIndices.begin(), + vectorParamIndices.end(), + [&lenIdx]( std::pair const & vpi ) { return vpi.second == lenIdx; } ); + return ( lenVectorParamIt == vectorParamIndices.end() ) + ? lenParts[0] + : ( startLowerCase( stripPrefix( params[lenVectorParamIt->first].name, "p" ) ) + ".size()" ); + } + break; case 2: return startLowerCase( stripPrefix( lenParts[0], "p" ) ) + "." + lenParts[1]; break; default: assert( false ); return ""; } @@ -11726,9 +11736,9 @@ bool VulkanHppGenerator::isHandleType( std::string const & type ) const auto it = m_handles.find( type ); if ( it == m_handles.end() ) { - it = std::find_if( m_handles.begin(), m_handles.end(), [&type]( std::pair const & hd ) { - return hd.second.alias == type; - } ); + it = std::find_if( m_handles.begin(), + m_handles.end(), + [&type]( std::pair const & hd ) { return hd.second.alias == type; } ); } return ( it != m_handles.end() ); } @@ -11755,8 +11765,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, std::vec assert( structureIt != m_structures.end() ); assert( std::find_if( structureIt->second.members.begin(), structureIt->second.members.end(), - [&n = nameParts[1]]( MemberData const & md ) { return md.name == n; } ) != - structureIt->second.members.end() ); + [&n = nameParts[1]]( MemberData const & md ) + { return md.name == n; } ) != structureIt->second.members.end() ); #endif return true; } @@ -11780,8 +11790,8 @@ bool VulkanHppGenerator::isLenByStructMember( std::string const & name, ParamDat assert( structureIt != m_structures.end() ); assert( std::find_if( structureIt->second.members.begin(), structureIt->second.members.end(), - [&n = nameParts[1]]( MemberData const & md ) { return md.name == n; } ) != - structureIt->second.members.end() ); + [&n = nameParts[1]]( MemberData const & md ) + { return md.name == n; } ) != structureIt->second.members.end() ); #endif return true; } @@ -11823,10 +11833,10 @@ bool VulkanHppGenerator::isStructureChainAnchor( std::string const & type ) cons auto it = m_structures.find( type ); if ( it == m_structures.end() ) { - it = std::find_if( - m_structures.begin(), m_structures.end(), [&type]( std::pair const & sd ) { - return sd.second.aliases.find( type ) != sd.second.aliases.end(); - } ); + it = std::find_if( m_structures.begin(), + m_structures.end(), + [&type]( std::pair const & sd ) + { return sd.second.aliases.find( type ) != sd.second.aliases.end(); } ); } if ( it != m_structures.end() ) { @@ -11855,8 +11865,8 @@ std::pair>> } return std::make_pair( std::find_if( countToVectorMap.begin(), countToVectorMap.end(), - []( auto const & cvm ) { return 1 < cvm.second.size(); } ) != - countToVectorMap.end(), + []( auto const & cvm ) + { return 1 < cvm.second.size(); } ) != countToVectorMap.end(), countToVectorMap ); } @@ -12444,9 +12454,9 @@ void VulkanHppGenerator::readEnums( tinyxml2::XMLElement const * element ) bool bitmask = ( type == "bitmask" ); if ( bitmask ) { - auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&name]( auto const & bitmask ) { - return bitmask.second.requirements == name; - } ); + auto bitmaskIt = std::find_if( m_bitmasks.begin(), + m_bitmasks.end(), + [&name]( auto const & bitmask ) { return bitmask.second.requirements == name; } ); check( bitmaskIt != m_bitmasks.end(), line, "enum <" + name + "> is not listed as an requires or bitvalues for any bitmask in the types section" ); @@ -12546,9 +12556,8 @@ void VulkanHppGenerator::readExtension( tinyxml2::XMLElement const * element ) std::string const & requiresCore = attribute.second; check( std::find_if( m_features.begin(), m_features.end(), - [&requiresCore]( std::pair const & nameNumber ) { - return nameNumber.second == requiresCore; - } ) != m_features.end(), + [&requiresCore]( std::pair const & nameNumber ) + { return nameNumber.second == requiresCore; } ) != m_features.end(), line, "unknown feature number <" + attribute.second + ">" ); } @@ -12653,36 +12662,37 @@ void VulkanHppGenerator::readExtensionDisabledType( tinyxml2::XMLElement const * switch ( typeIt->second.category ) { case TypeCategory::Bitmask: - { - auto bitmasksIt = m_bitmasks.find( name ); - check( bitmasksIt != m_bitmasks.end(), line, "trying to remove unknown bitmask <" + name + ">" ); - check( bitmasksIt->second.alias.empty(), - line, - "trying to remove disabled bitmask <" + name + "> which has alias <" + bitmasksIt->second.alias + ">" ); - m_bitmasks.erase( bitmasksIt ); - } - break; + { + auto bitmasksIt = m_bitmasks.find( name ); + check( bitmasksIt != m_bitmasks.end(), line, "trying to remove unknown bitmask <" + name + ">" ); + check( bitmasksIt->second.alias.empty(), + line, + "trying to remove disabled bitmask <" + name + "> which has alias <" + bitmasksIt->second.alias + + ">" ); + m_bitmasks.erase( bitmasksIt ); + } + break; case TypeCategory::Enum: - { - auto enumIt = m_enums.find( name ); - check( enumIt != m_enums.end(), line, "trying to remove unknown enum <" + name + ">" ); - check( enumIt->second.alias.empty(), - line, - "trying to remove disabled enum <" + name + "> which has alias <" + enumIt->second.alias + ">" ); - m_enums.erase( enumIt ); - } - break; + { + auto enumIt = m_enums.find( name ); + check( enumIt != m_enums.end(), line, "trying to remove unknown enum <" + name + ">" ); + check( enumIt->second.alias.empty(), + line, + "trying to remove disabled enum <" + name + "> which has alias <" + enumIt->second.alias + ">" ); + m_enums.erase( enumIt ); + } + break; case TypeCategory::Struct: - { - auto structIt = m_structures.find( name ); - check( structIt != m_structures.end(), line, "trying to remove unknown struct <" + name + ">" ); - check( structIt->second.aliases.empty(), - line, - "trying to remove disabled structure <" + name + "> which has " + - std::to_string( structIt->second.aliases.size() ) + "aliases" ); - m_structures.erase( structIt ); - } - break; + { + auto structIt = m_structures.find( name ); + check( structIt != m_structures.end(), line, "trying to remove unknown struct <" + name + ">" ); + check( structIt->second.aliases.empty(), + line, + "trying to remove disabled structure <" + name + "> which has " + + std::to_string( structIt->second.aliases.size() ) + "aliases" ); + m_structures.erase( structIt ); + } + break; default: check( false, line, @@ -13078,9 +13088,8 @@ void VulkanHppGenerator::readPlatform( tinyxml2::XMLElement const * element ) check( std::find_if( m_platforms.begin(), m_platforms.end(), - [&protect]( std::pair const & p ) { - return p.second.protect == protect; - } ) == m_platforms.end(), + [&protect]( std::pair const & p ) + { return p.second.protect == protect; } ) == m_platforms.end(), line, "platform protect <" + protect + "> already specified" ); check( m_platforms.insert( std::make_pair( name, PlatformData( protect ) ) ).second, @@ -13679,8 +13688,8 @@ void VulkanHppGenerator::readStruct( tinyxml2::XMLElement const * // check if multiple structure members use the very same (not empty) len attribute // Note: even though the arrays are not mared as optional, they still might be mutually exclusive (like in - // VkWriteDescriptorSet)! That is, there's not enough information available in vk.xml to decide on that, so we need - // this external knowledge! + // VkWriteDescriptorSet)! That is, there's not enough information available in vk.xml to decide on that, so we + // need this external knowledge! static std::set mutualExclusiveStructs = { "VkAccelerationStructureBuildGeometryInfoKHR", "VkWriteDescriptorSet" }; static std::set multipleLenStructs = { "VkImageConstraintsInfoFUCHSIA", diff --git a/VulkanHppGenerator.hpp b/VulkanHppGenerator.hpp index 99b1dc5..6db7f8a 100644 --- a/VulkanHppGenerator.hpp +++ b/VulkanHppGenerator.hpp @@ -971,7 +971,9 @@ private: std::string const & structName, std::string const & prefix, bool mutualExclusiveLens ) const; - std::set getPlatforms( std::set const & extensions ) const; + std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) const; + std::set getPlatforms( + std::set const & extensions ) const; std::pair getPoolTypeAndName( std::string const & type ) const; std::string getVectorSize( std::vector const & params, std::map const & vectorParamIndices, diff --git a/vulkan/vulkan.hpp b/vulkan/vulkan.hpp index decec63..ad4e55c 100644 --- a/vulkan/vulkan.hpp +++ b/vulkan/vulkan.hpp @@ -67,7 +67,7 @@ #endif #if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 -# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) # include # elif defined( _WIN32 ) typedef struct HINSTANCE__ * HINSTANCE; @@ -5444,79 +5444,79 @@ namespace VULKAN_HPP_NAMESPACE enum class AccessFlagBits2KHR : VkAccessFlags2KHR { - e2None = VK_ACCESS_2_NONE_KHR, - e2IndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, - e2IndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR, - e2VertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, - e2UniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR, - e2InputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, - e2ShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR, - e2ShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR, - e2ColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, - e2ColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, - e2DepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, - e2DepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, - e2TransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR, - e2TransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, - e2HostRead = VK_ACCESS_2_HOST_READ_BIT_KHR, - e2HostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR, - e2MemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR, - e2MemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR, - e2ShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, - e2ShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, - e2ShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, - e2TransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, - e2TransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, - e2TransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, - e2ConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, - e2CommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, - e2CommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, - e2FragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - e2AccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, - e2AccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - e2FragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, - e2ColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, - e2AccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, - e2AccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, - e2ShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV + eNone = VK_ACCESS_2_NONE_KHR, + eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR, + eIndexRead = VK_ACCESS_2_INDEX_READ_BIT_KHR, + eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR, + eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT_KHR, + eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR, + eShaderRead = VK_ACCESS_2_SHADER_READ_BIT_KHR, + eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT_KHR, + eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR, + eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR, + eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR, + eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR, + eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT_KHR, + eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR, + eHostRead = VK_ACCESS_2_HOST_READ_BIT_KHR, + eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT_KHR, + eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT_KHR, + eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT_KHR, + eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR, + eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR, + eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR, + eTransformFeedbackWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, + eTransformFeedbackCounterReadExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, + eTransformFeedbackCounterWriteExt = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, + eConditionalRenderingReadExt = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, + eCommandPreprocessReadNv = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, + eCommandPreprocessWriteNv = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, + eFragmentShadingRateAttachmentRead = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + eAccelerationStructureRead = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, + eAccelerationStructureWrite = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + eFragmentDensityMapReadExt = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, + eColorAttachmentReadNoncoherentExt = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, + eAccelerationStructureReadNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, + eAccelerationStructureWriteNv = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, + eShadingRateImageReadNv = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV }; VULKAN_HPP_INLINE std::string to_string( AccessFlagBits2KHR value ) { switch ( value ) { - case AccessFlagBits2KHR::e2None: return "2None"; - case AccessFlagBits2KHR::e2IndirectCommandRead: return "2IndirectCommandRead"; - case AccessFlagBits2KHR::e2IndexRead: return "2IndexRead"; - case AccessFlagBits2KHR::e2VertexAttributeRead: return "2VertexAttributeRead"; - case AccessFlagBits2KHR::e2UniformRead: return "2UniformRead"; - case AccessFlagBits2KHR::e2InputAttachmentRead: return "2InputAttachmentRead"; - case AccessFlagBits2KHR::e2ShaderRead: return "2ShaderRead"; - case AccessFlagBits2KHR::e2ShaderWrite: return "2ShaderWrite"; - case AccessFlagBits2KHR::e2ColorAttachmentRead: return "2ColorAttachmentRead"; - case AccessFlagBits2KHR::e2ColorAttachmentWrite: return "2ColorAttachmentWrite"; - case AccessFlagBits2KHR::e2DepthStencilAttachmentRead: return "2DepthStencilAttachmentRead"; - case AccessFlagBits2KHR::e2DepthStencilAttachmentWrite: return "2DepthStencilAttachmentWrite"; - case AccessFlagBits2KHR::e2TransferRead: return "2TransferRead"; - case AccessFlagBits2KHR::e2TransferWrite: return "2TransferWrite"; - case AccessFlagBits2KHR::e2HostRead: return "2HostRead"; - case AccessFlagBits2KHR::e2HostWrite: return "2HostWrite"; - case AccessFlagBits2KHR::e2MemoryRead: return "2MemoryRead"; - case AccessFlagBits2KHR::e2MemoryWrite: return "2MemoryWrite"; - case AccessFlagBits2KHR::e2ShaderSampledRead: return "2ShaderSampledRead"; - case AccessFlagBits2KHR::e2ShaderStorageRead: return "2ShaderStorageRead"; - case AccessFlagBits2KHR::e2ShaderStorageWrite: return "2ShaderStorageWrite"; - case AccessFlagBits2KHR::e2TransformFeedbackWriteExt: return "2TransformFeedbackWriteExt"; - case AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt: return "2TransformFeedbackCounterReadExt"; - case AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt: return "2TransformFeedbackCounterWriteExt"; - case AccessFlagBits2KHR::e2ConditionalRenderingReadExt: return "2ConditionalRenderingReadExt"; - case AccessFlagBits2KHR::e2CommandPreprocessReadNv: return "2CommandPreprocessReadNv"; - case AccessFlagBits2KHR::e2CommandPreprocessWriteNv: return "2CommandPreprocessWriteNv"; - case AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead: return "2FragmentShadingRateAttachmentRead"; - case AccessFlagBits2KHR::e2AccelerationStructureRead: return "2AccelerationStructureRead"; - case AccessFlagBits2KHR::e2AccelerationStructureWrite: return "2AccelerationStructureWrite"; - case AccessFlagBits2KHR::e2FragmentDensityMapReadExt: return "2FragmentDensityMapReadExt"; - case AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt: return "2ColorAttachmentReadNoncoherentExt"; + case AccessFlagBits2KHR::eNone: return "None"; + case AccessFlagBits2KHR::eIndirectCommandRead: return "IndirectCommandRead"; + case AccessFlagBits2KHR::eIndexRead: return "IndexRead"; + case AccessFlagBits2KHR::eVertexAttributeRead: return "VertexAttributeRead"; + case AccessFlagBits2KHR::eUniformRead: return "UniformRead"; + case AccessFlagBits2KHR::eInputAttachmentRead: return "InputAttachmentRead"; + case AccessFlagBits2KHR::eShaderRead: return "ShaderRead"; + case AccessFlagBits2KHR::eShaderWrite: return "ShaderWrite"; + case AccessFlagBits2KHR::eColorAttachmentRead: return "ColorAttachmentRead"; + case AccessFlagBits2KHR::eColorAttachmentWrite: return "ColorAttachmentWrite"; + case AccessFlagBits2KHR::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead"; + case AccessFlagBits2KHR::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite"; + case AccessFlagBits2KHR::eTransferRead: return "TransferRead"; + case AccessFlagBits2KHR::eTransferWrite: return "TransferWrite"; + case AccessFlagBits2KHR::eHostRead: return "HostRead"; + case AccessFlagBits2KHR::eHostWrite: return "HostWrite"; + case AccessFlagBits2KHR::eMemoryRead: return "MemoryRead"; + case AccessFlagBits2KHR::eMemoryWrite: return "MemoryWrite"; + case AccessFlagBits2KHR::eShaderSampledRead: return "ShaderSampledRead"; + case AccessFlagBits2KHR::eShaderStorageRead: return "ShaderStorageRead"; + case AccessFlagBits2KHR::eShaderStorageWrite: return "ShaderStorageWrite"; + case AccessFlagBits2KHR::eTransformFeedbackWriteExt: return "TransformFeedbackWriteExt"; + case AccessFlagBits2KHR::eTransformFeedbackCounterReadExt: return "TransformFeedbackCounterReadExt"; + case AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt: return "TransformFeedbackCounterWriteExt"; + case AccessFlagBits2KHR::eConditionalRenderingReadExt: return "ConditionalRenderingReadExt"; + case AccessFlagBits2KHR::eCommandPreprocessReadNv: return "CommandPreprocessReadNv"; + case AccessFlagBits2KHR::eCommandPreprocessWriteNv: return "CommandPreprocessWriteNv"; + case AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead: return "FragmentShadingRateAttachmentRead"; + case AccessFlagBits2KHR::eAccelerationStructureRead: return "AccelerationStructureRead"; + case AccessFlagBits2KHR::eAccelerationStructureWrite: return "AccelerationStructureWrite"; + case AccessFlagBits2KHR::eFragmentDensityMapReadExt: return "FragmentDensityMapReadExt"; + case AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt: return "ColorAttachmentReadNoncoherentExt"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -8975,84 +8975,84 @@ namespace VULKAN_HPP_NAMESPACE enum class PipelineStageFlagBits2KHR : VkPipelineStageFlags2KHR { - e2None = VK_PIPELINE_STAGE_2_NONE_KHR, - e2TopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, - e2DrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, - e2VertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, - e2VertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR, - e2TessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR, - e2TessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR, - e2GeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR, - e2FragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, - e2EarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, - e2LateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, - e2ColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, - e2ComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR, - e2AllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, - e2BottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, - e2Host = VK_PIPELINE_STAGE_2_HOST_BIT_KHR, - e2AllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, - e2AllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, - e2Copy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR, - e2Resolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, - e2Blit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, - e2Clear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, - e2IndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, - e2VertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, - e2PreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR, - e2TransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, - e2ConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, - e2CommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, - e2FragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - e2AccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - e2RayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, - e2FragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, - e2TaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, - e2MeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, - e2AccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, - e2RayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, - e2ShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, - e2Transfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR + eNone = VK_PIPELINE_STAGE_2_NONE_KHR, + eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, + eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR, + eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR, + eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR, + eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR, + eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR, + eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR, + eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, + eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR, + eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR, + eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR, + eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR, + eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR, + eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, + eHost = VK_PIPELINE_STAGE_2_HOST_BIT_KHR, + eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR, + eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, + eCopy = VK_PIPELINE_STAGE_2_COPY_BIT_KHR, + eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR, + eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT_KHR, + eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR, + eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR, + eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR, + ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR, + eTransformFeedbackExt = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, + eConditionalRenderingExt = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, + eCommandPreprocessNv = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, + eFragmentShadingRateAttachment = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eAccelerationStructureBuild = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + eRayTracingShader = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, + eFragmentDensityProcessExt = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, + eTaskShaderNv = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, + eMeshShaderNv = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, + eAccelerationStructureBuildNv = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, + eRayTracingShaderNv = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, + eShadingRateImageNv = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, + eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR }; VULKAN_HPP_INLINE std::string to_string( PipelineStageFlagBits2KHR value ) { switch ( value ) { - case PipelineStageFlagBits2KHR::e2None: return "2None"; - case PipelineStageFlagBits2KHR::e2TopOfPipe: return "2TopOfPipe"; - case PipelineStageFlagBits2KHR::e2DrawIndirect: return "2DrawIndirect"; - case PipelineStageFlagBits2KHR::e2VertexInput: return "2VertexInput"; - case PipelineStageFlagBits2KHR::e2VertexShader: return "2VertexShader"; - case PipelineStageFlagBits2KHR::e2TessellationControlShader: return "2TessellationControlShader"; - case PipelineStageFlagBits2KHR::e2TessellationEvaluationShader: return "2TessellationEvaluationShader"; - case PipelineStageFlagBits2KHR::e2GeometryShader: return "2GeometryShader"; - case PipelineStageFlagBits2KHR::e2FragmentShader: return "2FragmentShader"; - case PipelineStageFlagBits2KHR::e2EarlyFragmentTests: return "2EarlyFragmentTests"; - case PipelineStageFlagBits2KHR::e2LateFragmentTests: return "2LateFragmentTests"; - case PipelineStageFlagBits2KHR::e2ColorAttachmentOutput: return "2ColorAttachmentOutput"; - case PipelineStageFlagBits2KHR::e2ComputeShader: return "2ComputeShader"; - case PipelineStageFlagBits2KHR::e2AllTransfer: return "2AllTransfer"; - case PipelineStageFlagBits2KHR::e2BottomOfPipe: return "2BottomOfPipe"; - case PipelineStageFlagBits2KHR::e2Host: return "2Host"; - case PipelineStageFlagBits2KHR::e2AllGraphics: return "2AllGraphics"; - case PipelineStageFlagBits2KHR::e2AllCommands: return "2AllCommands"; - case PipelineStageFlagBits2KHR::e2Copy: return "2Copy"; - case PipelineStageFlagBits2KHR::e2Resolve: return "2Resolve"; - case PipelineStageFlagBits2KHR::e2Blit: return "2Blit"; - case PipelineStageFlagBits2KHR::e2Clear: return "2Clear"; - case PipelineStageFlagBits2KHR::e2IndexInput: return "2IndexInput"; - case PipelineStageFlagBits2KHR::e2VertexAttributeInput: return "2VertexAttributeInput"; - case PipelineStageFlagBits2KHR::e2PreRasterizationShaders: return "2PreRasterizationShaders"; - case PipelineStageFlagBits2KHR::e2TransformFeedbackExt: return "2TransformFeedbackExt"; - case PipelineStageFlagBits2KHR::e2ConditionalRenderingExt: return "2ConditionalRenderingExt"; - case PipelineStageFlagBits2KHR::e2CommandPreprocessNv: return "2CommandPreprocessNv"; - case PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment: return "2FragmentShadingRateAttachment"; - case PipelineStageFlagBits2KHR::e2AccelerationStructureBuild: return "2AccelerationStructureBuild"; - case PipelineStageFlagBits2KHR::e2RayTracingShader: return "2RayTracingShader"; - case PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt: return "2FragmentDensityProcessExt"; - case PipelineStageFlagBits2KHR::e2TaskShaderNv: return "2TaskShaderNv"; - case PipelineStageFlagBits2KHR::e2MeshShaderNv: return "2MeshShaderNv"; + case PipelineStageFlagBits2KHR::eNone: return "None"; + case PipelineStageFlagBits2KHR::eTopOfPipe: return "TopOfPipe"; + case PipelineStageFlagBits2KHR::eDrawIndirect: return "DrawIndirect"; + case PipelineStageFlagBits2KHR::eVertexInput: return "VertexInput"; + case PipelineStageFlagBits2KHR::eVertexShader: return "VertexShader"; + case PipelineStageFlagBits2KHR::eTessellationControlShader: return "TessellationControlShader"; + case PipelineStageFlagBits2KHR::eTessellationEvaluationShader: return "TessellationEvaluationShader"; + case PipelineStageFlagBits2KHR::eGeometryShader: return "GeometryShader"; + case PipelineStageFlagBits2KHR::eFragmentShader: return "FragmentShader"; + case PipelineStageFlagBits2KHR::eEarlyFragmentTests: return "EarlyFragmentTests"; + case PipelineStageFlagBits2KHR::eLateFragmentTests: return "LateFragmentTests"; + case PipelineStageFlagBits2KHR::eColorAttachmentOutput: return "ColorAttachmentOutput"; + case PipelineStageFlagBits2KHR::eComputeShader: return "ComputeShader"; + case PipelineStageFlagBits2KHR::eAllTransfer: return "AllTransfer"; + case PipelineStageFlagBits2KHR::eBottomOfPipe: return "BottomOfPipe"; + case PipelineStageFlagBits2KHR::eHost: return "Host"; + case PipelineStageFlagBits2KHR::eAllGraphics: return "AllGraphics"; + case PipelineStageFlagBits2KHR::eAllCommands: return "AllCommands"; + case PipelineStageFlagBits2KHR::eCopy: return "Copy"; + case PipelineStageFlagBits2KHR::eResolve: return "Resolve"; + case PipelineStageFlagBits2KHR::eBlit: return "Blit"; + case PipelineStageFlagBits2KHR::eClear: return "Clear"; + case PipelineStageFlagBits2KHR::eIndexInput: return "IndexInput"; + case PipelineStageFlagBits2KHR::eVertexAttributeInput: return "VertexAttributeInput"; + case PipelineStageFlagBits2KHR::ePreRasterizationShaders: return "PreRasterizationShaders"; + case PipelineStageFlagBits2KHR::eTransformFeedbackExt: return "TransformFeedbackExt"; + case PipelineStageFlagBits2KHR::eConditionalRenderingExt: return "ConditionalRenderingExt"; + case PipelineStageFlagBits2KHR::eCommandPreprocessNv: return "CommandPreprocessNv"; + case PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; + case PipelineStageFlagBits2KHR::eAccelerationStructureBuild: return "AccelerationStructureBuild"; + case PipelineStageFlagBits2KHR::eRayTracingShader: return "RayTracingShader"; + case PipelineStageFlagBits2KHR::eFragmentDensityProcessExt: return "FragmentDensityProcessExt"; + case PipelineStageFlagBits2KHR::eTaskShaderNv: return "TaskShaderNv"; + case PipelineStageFlagBits2KHR::eMeshShaderNv: return "MeshShaderNv"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -11868,30 +11868,28 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags64 { allFlags = - VkFlags64( AccessFlagBits2KHR::e2None ) | VkFlags64( AccessFlagBits2KHR::e2IndirectCommandRead ) | - VkFlags64( AccessFlagBits2KHR::e2IndexRead ) | VkFlags64( AccessFlagBits2KHR::e2VertexAttributeRead ) | - VkFlags64( AccessFlagBits2KHR::e2UniformRead ) | VkFlags64( AccessFlagBits2KHR::e2InputAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderWrite ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentWrite ) | - VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) | - VkFlags64( AccessFlagBits2KHR::e2TransferRead ) | VkFlags64( AccessFlagBits2KHR::e2TransferWrite ) | - VkFlags64( AccessFlagBits2KHR::e2HostRead ) | VkFlags64( AccessFlagBits2KHR::e2HostWrite ) | - VkFlags64( AccessFlagBits2KHR::e2MemoryRead ) | VkFlags64( AccessFlagBits2KHR::e2MemoryWrite ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderSampledRead ) | VkFlags64( AccessFlagBits2KHR::e2ShaderStorageRead ) | - VkFlags64( AccessFlagBits2KHR::e2ShaderStorageWrite ) | - VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) | - VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) | - VkFlags64( AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessReadNv ) | - VkFlags64( AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) | - VkFlags64( AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) | - VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureRead ) | - VkFlags64( AccessFlagBits2KHR::e2AccelerationStructureWrite ) | - VkFlags64( AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) | - VkFlags64( AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt ) + VkFlags64( AccessFlagBits2KHR::eNone ) | VkFlags64( AccessFlagBits2KHR::eIndirectCommandRead ) | + VkFlags64( AccessFlagBits2KHR::eIndexRead ) | VkFlags64( AccessFlagBits2KHR::eVertexAttributeRead ) | + VkFlags64( AccessFlagBits2KHR::eUniformRead ) | VkFlags64( AccessFlagBits2KHR::eInputAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eShaderRead ) | VkFlags64( AccessFlagBits2KHR::eShaderWrite ) | + VkFlags64( AccessFlagBits2KHR::eColorAttachmentRead ) | VkFlags64( AccessFlagBits2KHR::eColorAttachmentWrite ) | + VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) | VkFlags64( AccessFlagBits2KHR::eTransferRead ) | + VkFlags64( AccessFlagBits2KHR::eTransferWrite ) | VkFlags64( AccessFlagBits2KHR::eHostRead ) | + VkFlags64( AccessFlagBits2KHR::eHostWrite ) | VkFlags64( AccessFlagBits2KHR::eMemoryRead ) | + VkFlags64( AccessFlagBits2KHR::eMemoryWrite ) | VkFlags64( AccessFlagBits2KHR::eShaderSampledRead ) | + VkFlags64( AccessFlagBits2KHR::eShaderStorageRead ) | VkFlags64( AccessFlagBits2KHR::eShaderStorageWrite ) | + VkFlags64( AccessFlagBits2KHR::eTransformFeedbackWriteExt ) | + VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) | + VkFlags64( AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) | + VkFlags64( AccessFlagBits2KHR::eConditionalRenderingReadExt ) | + VkFlags64( AccessFlagBits2KHR::eCommandPreprocessReadNv ) | + VkFlags64( AccessFlagBits2KHR::eCommandPreprocessWriteNv ) | + VkFlags64( AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) | + VkFlags64( AccessFlagBits2KHR::eAccelerationStructureRead ) | + VkFlags64( AccessFlagBits2KHR::eAccelerationStructureWrite ) | + VkFlags64( AccessFlagBits2KHR::eFragmentDensityMapReadExt ) | + VkFlags64( AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt ) }; }; @@ -11924,68 +11922,68 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & AccessFlagBits2KHR::e2IndirectCommandRead ) - result += "2IndirectCommandRead | "; - if ( value & AccessFlagBits2KHR::e2IndexRead ) - result += "2IndexRead | "; - if ( value & AccessFlagBits2KHR::e2VertexAttributeRead ) - result += "2VertexAttributeRead | "; - if ( value & AccessFlagBits2KHR::e2UniformRead ) - result += "2UniformRead | "; - if ( value & AccessFlagBits2KHR::e2InputAttachmentRead ) - result += "2InputAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderRead ) - result += "2ShaderRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderWrite ) - result += "2ShaderWrite | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentRead ) - result += "2ColorAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentWrite ) - result += "2ColorAttachmentWrite | "; - if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentRead ) - result += "2DepthStencilAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2DepthStencilAttachmentWrite ) - result += "2DepthStencilAttachmentWrite | "; - if ( value & AccessFlagBits2KHR::e2TransferRead ) - result += "2TransferRead | "; - if ( value & AccessFlagBits2KHR::e2TransferWrite ) - result += "2TransferWrite | "; - if ( value & AccessFlagBits2KHR::e2HostRead ) - result += "2HostRead | "; - if ( value & AccessFlagBits2KHR::e2HostWrite ) - result += "2HostWrite | "; - if ( value & AccessFlagBits2KHR::e2MemoryRead ) - result += "2MemoryRead | "; - if ( value & AccessFlagBits2KHR::e2MemoryWrite ) - result += "2MemoryWrite | "; - if ( value & AccessFlagBits2KHR::e2ShaderSampledRead ) - result += "2ShaderSampledRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderStorageRead ) - result += "2ShaderStorageRead | "; - if ( value & AccessFlagBits2KHR::e2ShaderStorageWrite ) - result += "2ShaderStorageWrite | "; - if ( value & AccessFlagBits2KHR::e2TransformFeedbackWriteExt ) - result += "2TransformFeedbackWriteExt | "; - if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterReadExt ) - result += "2TransformFeedbackCounterReadExt | "; - if ( value & AccessFlagBits2KHR::e2TransformFeedbackCounterWriteExt ) - result += "2TransformFeedbackCounterWriteExt | "; - if ( value & AccessFlagBits2KHR::e2ConditionalRenderingReadExt ) - result += "2ConditionalRenderingReadExt | "; - if ( value & AccessFlagBits2KHR::e2CommandPreprocessReadNv ) - result += "2CommandPreprocessReadNv | "; - if ( value & AccessFlagBits2KHR::e2CommandPreprocessWriteNv ) - result += "2CommandPreprocessWriteNv | "; - if ( value & AccessFlagBits2KHR::e2FragmentShadingRateAttachmentRead ) - result += "2FragmentShadingRateAttachmentRead | "; - if ( value & AccessFlagBits2KHR::e2AccelerationStructureRead ) - result += "2AccelerationStructureRead | "; - if ( value & AccessFlagBits2KHR::e2AccelerationStructureWrite ) - result += "2AccelerationStructureWrite | "; - if ( value & AccessFlagBits2KHR::e2FragmentDensityMapReadExt ) - result += "2FragmentDensityMapReadExt | "; - if ( value & AccessFlagBits2KHR::e2ColorAttachmentReadNoncoherentExt ) - result += "2ColorAttachmentReadNoncoherentExt | "; + if ( value & AccessFlagBits2KHR::eIndirectCommandRead ) + result += "IndirectCommandRead | "; + if ( value & AccessFlagBits2KHR::eIndexRead ) + result += "IndexRead | "; + if ( value & AccessFlagBits2KHR::eVertexAttributeRead ) + result += "VertexAttributeRead | "; + if ( value & AccessFlagBits2KHR::eUniformRead ) + result += "UniformRead | "; + if ( value & AccessFlagBits2KHR::eInputAttachmentRead ) + result += "InputAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eShaderRead ) + result += "ShaderRead | "; + if ( value & AccessFlagBits2KHR::eShaderWrite ) + result += "ShaderWrite | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentRead ) + result += "ColorAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentWrite ) + result += "ColorAttachmentWrite | "; + if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentRead ) + result += "DepthStencilAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eDepthStencilAttachmentWrite ) + result += "DepthStencilAttachmentWrite | "; + if ( value & AccessFlagBits2KHR::eTransferRead ) + result += "TransferRead | "; + if ( value & AccessFlagBits2KHR::eTransferWrite ) + result += "TransferWrite | "; + if ( value & AccessFlagBits2KHR::eHostRead ) + result += "HostRead | "; + if ( value & AccessFlagBits2KHR::eHostWrite ) + result += "HostWrite | "; + if ( value & AccessFlagBits2KHR::eMemoryRead ) + result += "MemoryRead | "; + if ( value & AccessFlagBits2KHR::eMemoryWrite ) + result += "MemoryWrite | "; + if ( value & AccessFlagBits2KHR::eShaderSampledRead ) + result += "ShaderSampledRead | "; + if ( value & AccessFlagBits2KHR::eShaderStorageRead ) + result += "ShaderStorageRead | "; + if ( value & AccessFlagBits2KHR::eShaderStorageWrite ) + result += "ShaderStorageWrite | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackWriteExt ) + result += "TransformFeedbackWriteExt | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterReadExt ) + result += "TransformFeedbackCounterReadExt | "; + if ( value & AccessFlagBits2KHR::eTransformFeedbackCounterWriteExt ) + result += "TransformFeedbackCounterWriteExt | "; + if ( value & AccessFlagBits2KHR::eConditionalRenderingReadExt ) + result += "ConditionalRenderingReadExt | "; + if ( value & AccessFlagBits2KHR::eCommandPreprocessReadNv ) + result += "CommandPreprocessReadNv | "; + if ( value & AccessFlagBits2KHR::eCommandPreprocessWriteNv ) + result += "CommandPreprocessWriteNv | "; + if ( value & AccessFlagBits2KHR::eFragmentShadingRateAttachmentRead ) + result += "FragmentShadingRateAttachmentRead | "; + if ( value & AccessFlagBits2KHR::eAccelerationStructureRead ) + result += "AccelerationStructureRead | "; + if ( value & AccessFlagBits2KHR::eAccelerationStructureWrite ) + result += "AccelerationStructureWrite | "; + if ( value & AccessFlagBits2KHR::eFragmentDensityMapReadExt ) + result += "FragmentDensityMapReadExt | "; + if ( value & AccessFlagBits2KHR::eColorAttachmentReadNoncoherentExt ) + result += "ColorAttachmentReadNoncoherentExt | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -15633,32 +15631,32 @@ namespace VULKAN_HPP_NAMESPACE enum : VkFlags64 { allFlags = - VkFlags64( PipelineStageFlagBits2KHR::e2None ) | VkFlags64( PipelineStageFlagBits2KHR::e2TopOfPipe ) | - VkFlags64( PipelineStageFlagBits2KHR::e2DrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::e2VertexInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2VertexShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TessellationControlShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2GeometryShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) | - VkFlags64( PipelineStageFlagBits2KHR::e2LateFragmentTests ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ComputeShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AllTransfer ) | VkFlags64( PipelineStageFlagBits2KHR::e2BottomOfPipe ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Host ) | VkFlags64( PipelineStageFlagBits2KHR::e2AllGraphics ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AllCommands ) | VkFlags64( PipelineStageFlagBits2KHR::e2Copy ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Resolve ) | VkFlags64( PipelineStageFlagBits2KHR::e2Blit ) | - VkFlags64( PipelineStageFlagBits2KHR::e2Clear ) | VkFlags64( PipelineStageFlagBits2KHR::e2IndexInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2VertexAttributeInput ) | - VkFlags64( PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) | - VkFlags64( PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) | - VkFlags64( PipelineStageFlagBits2KHR::e2RayTracingShader ) | - VkFlags64( PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) | - VkFlags64( PipelineStageFlagBits2KHR::e2TaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::e2MeshShaderNv ) + VkFlags64( PipelineStageFlagBits2KHR::eNone ) | VkFlags64( PipelineStageFlagBits2KHR::eTopOfPipe ) | + VkFlags64( PipelineStageFlagBits2KHR::eDrawIndirect ) | VkFlags64( PipelineStageFlagBits2KHR::eVertexInput ) | + VkFlags64( PipelineStageFlagBits2KHR::eVertexShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eTessellationControlShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eGeometryShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eEarlyFragmentTests ) | + VkFlags64( PipelineStageFlagBits2KHR::eLateFragmentTests ) | + VkFlags64( PipelineStageFlagBits2KHR::eColorAttachmentOutput ) | + VkFlags64( PipelineStageFlagBits2KHR::eComputeShader ) | VkFlags64( PipelineStageFlagBits2KHR::eAllTransfer ) | + VkFlags64( PipelineStageFlagBits2KHR::eBottomOfPipe ) | VkFlags64( PipelineStageFlagBits2KHR::eHost ) | + VkFlags64( PipelineStageFlagBits2KHR::eAllGraphics ) | VkFlags64( PipelineStageFlagBits2KHR::eAllCommands ) | + VkFlags64( PipelineStageFlagBits2KHR::eCopy ) | VkFlags64( PipelineStageFlagBits2KHR::eResolve ) | + VkFlags64( PipelineStageFlagBits2KHR::eBlit ) | VkFlags64( PipelineStageFlagBits2KHR::eClear ) | + VkFlags64( PipelineStageFlagBits2KHR::eIndexInput ) | + VkFlags64( PipelineStageFlagBits2KHR::eVertexAttributeInput ) | + VkFlags64( PipelineStageFlagBits2KHR::ePreRasterizationShaders ) | + VkFlags64( PipelineStageFlagBits2KHR::eTransformFeedbackExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eConditionalRenderingExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eCommandPreprocessNv ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) | + VkFlags64( PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) | + VkFlags64( PipelineStageFlagBits2KHR::eRayTracingShader ) | + VkFlags64( PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) | + VkFlags64( PipelineStageFlagBits2KHR::eTaskShaderNv ) | VkFlags64( PipelineStageFlagBits2KHR::eMeshShaderNv ) }; }; @@ -15692,72 +15690,72 @@ namespace VULKAN_HPP_NAMESPACE return "{}"; std::string result; - if ( value & PipelineStageFlagBits2KHR::e2TopOfPipe ) - result += "2TopOfPipe | "; - if ( value & PipelineStageFlagBits2KHR::e2DrawIndirect ) - result += "2DrawIndirect | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexInput ) - result += "2VertexInput | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexShader ) - result += "2VertexShader | "; - if ( value & PipelineStageFlagBits2KHR::e2TessellationControlShader ) - result += "2TessellationControlShader | "; - if ( value & PipelineStageFlagBits2KHR::e2TessellationEvaluationShader ) - result += "2TessellationEvaluationShader | "; - if ( value & PipelineStageFlagBits2KHR::e2GeometryShader ) - result += "2GeometryShader | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentShader ) - result += "2FragmentShader | "; - if ( value & PipelineStageFlagBits2KHR::e2EarlyFragmentTests ) - result += "2EarlyFragmentTests | "; - if ( value & PipelineStageFlagBits2KHR::e2LateFragmentTests ) - result += "2LateFragmentTests | "; - if ( value & PipelineStageFlagBits2KHR::e2ColorAttachmentOutput ) - result += "2ColorAttachmentOutput | "; - if ( value & PipelineStageFlagBits2KHR::e2ComputeShader ) - result += "2ComputeShader | "; - if ( value & PipelineStageFlagBits2KHR::e2AllTransfer ) - result += "2AllTransfer | "; - if ( value & PipelineStageFlagBits2KHR::e2BottomOfPipe ) - result += "2BottomOfPipe | "; - if ( value & PipelineStageFlagBits2KHR::e2Host ) - result += "2Host | "; - if ( value & PipelineStageFlagBits2KHR::e2AllGraphics ) - result += "2AllGraphics | "; - if ( value & PipelineStageFlagBits2KHR::e2AllCommands ) - result += "2AllCommands | "; - if ( value & PipelineStageFlagBits2KHR::e2Copy ) - result += "2Copy | "; - if ( value & PipelineStageFlagBits2KHR::e2Resolve ) - result += "2Resolve | "; - if ( value & PipelineStageFlagBits2KHR::e2Blit ) - result += "2Blit | "; - if ( value & PipelineStageFlagBits2KHR::e2Clear ) - result += "2Clear | "; - if ( value & PipelineStageFlagBits2KHR::e2IndexInput ) - result += "2IndexInput | "; - if ( value & PipelineStageFlagBits2KHR::e2VertexAttributeInput ) - result += "2VertexAttributeInput | "; - if ( value & PipelineStageFlagBits2KHR::e2PreRasterizationShaders ) - result += "2PreRasterizationShaders | "; - if ( value & PipelineStageFlagBits2KHR::e2TransformFeedbackExt ) - result += "2TransformFeedbackExt | "; - if ( value & PipelineStageFlagBits2KHR::e2ConditionalRenderingExt ) - result += "2ConditionalRenderingExt | "; - if ( value & PipelineStageFlagBits2KHR::e2CommandPreprocessNv ) - result += "2CommandPreprocessNv | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentShadingRateAttachment ) - result += "2FragmentShadingRateAttachment | "; - if ( value & PipelineStageFlagBits2KHR::e2AccelerationStructureBuild ) - result += "2AccelerationStructureBuild | "; - if ( value & PipelineStageFlagBits2KHR::e2RayTracingShader ) - result += "2RayTracingShader | "; - if ( value & PipelineStageFlagBits2KHR::e2FragmentDensityProcessExt ) - result += "2FragmentDensityProcessExt | "; - if ( value & PipelineStageFlagBits2KHR::e2TaskShaderNv ) - result += "2TaskShaderNv | "; - if ( value & PipelineStageFlagBits2KHR::e2MeshShaderNv ) - result += "2MeshShaderNv | "; + if ( value & PipelineStageFlagBits2KHR::eTopOfPipe ) + result += "TopOfPipe | "; + if ( value & PipelineStageFlagBits2KHR::eDrawIndirect ) + result += "DrawIndirect | "; + if ( value & PipelineStageFlagBits2KHR::eVertexInput ) + result += "VertexInput | "; + if ( value & PipelineStageFlagBits2KHR::eVertexShader ) + result += "VertexShader | "; + if ( value & PipelineStageFlagBits2KHR::eTessellationControlShader ) + result += "TessellationControlShader | "; + if ( value & PipelineStageFlagBits2KHR::eTessellationEvaluationShader ) + result += "TessellationEvaluationShader | "; + if ( value & PipelineStageFlagBits2KHR::eGeometryShader ) + result += "GeometryShader | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentShader ) + result += "FragmentShader | "; + if ( value & PipelineStageFlagBits2KHR::eEarlyFragmentTests ) + result += "EarlyFragmentTests | "; + if ( value & PipelineStageFlagBits2KHR::eLateFragmentTests ) + result += "LateFragmentTests | "; + if ( value & PipelineStageFlagBits2KHR::eColorAttachmentOutput ) + result += "ColorAttachmentOutput | "; + if ( value & PipelineStageFlagBits2KHR::eComputeShader ) + result += "ComputeShader | "; + if ( value & PipelineStageFlagBits2KHR::eAllTransfer ) + result += "AllTransfer | "; + if ( value & PipelineStageFlagBits2KHR::eBottomOfPipe ) + result += "BottomOfPipe | "; + if ( value & PipelineStageFlagBits2KHR::eHost ) + result += "Host | "; + if ( value & PipelineStageFlagBits2KHR::eAllGraphics ) + result += "AllGraphics | "; + if ( value & PipelineStageFlagBits2KHR::eAllCommands ) + result += "AllCommands | "; + if ( value & PipelineStageFlagBits2KHR::eCopy ) + result += "Copy | "; + if ( value & PipelineStageFlagBits2KHR::eResolve ) + result += "Resolve | "; + if ( value & PipelineStageFlagBits2KHR::eBlit ) + result += "Blit | "; + if ( value & PipelineStageFlagBits2KHR::eClear ) + result += "Clear | "; + if ( value & PipelineStageFlagBits2KHR::eIndexInput ) + result += "IndexInput | "; + if ( value & PipelineStageFlagBits2KHR::eVertexAttributeInput ) + result += "VertexAttributeInput | "; + if ( value & PipelineStageFlagBits2KHR::ePreRasterizationShaders ) + result += "PreRasterizationShaders | "; + if ( value & PipelineStageFlagBits2KHR::eTransformFeedbackExt ) + result += "TransformFeedbackExt | "; + if ( value & PipelineStageFlagBits2KHR::eConditionalRenderingExt ) + result += "ConditionalRenderingExt | "; + if ( value & PipelineStageFlagBits2KHR::eCommandPreprocessNv ) + result += "CommandPreprocessNv | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentShadingRateAttachment ) + result += "FragmentShadingRateAttachment | "; + if ( value & PipelineStageFlagBits2KHR::eAccelerationStructureBuild ) + result += "AccelerationStructureBuild | "; + if ( value & PipelineStageFlagBits2KHR::eRayTracingShader ) + result += "RayTracingShader | "; + if ( value & PipelineStageFlagBits2KHR::eFragmentDensityProcessExt ) + result += "FragmentDensityProcessExt | "; + if ( value & PipelineStageFlagBits2KHR::eTaskShaderNv ) + result += "TaskShaderNv | "; + if ( value & PipelineStageFlagBits2KHR::eMeshShaderNv ) + result += "MeshShaderNv | "; return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } @@ -17777,7 +17775,7 @@ namespace VULKAN_HPP_NAMESPACE throwResultException( result, message ); } #endif - return ResultValue( result, data ); + return ResultValue( result, std::move( data ) ); } #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -112145,7 +112143,7 @@ namespace VULKAN_HPP_NAMESPACE { if ( !vulkanLibraryName.empty() ) { -# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL ); # elif defined( _WIN32 ) m_library = ::LoadLibraryA( vulkanLibraryName.c_str() ); @@ -112155,7 +112153,7 @@ namespace VULKAN_HPP_NAMESPACE } else { -# if defined( __linux__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); if ( m_library == nullptr ) { @@ -112199,7 +112197,7 @@ namespace VULKAN_HPP_NAMESPACE { if ( m_library ) { -# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) dlclose( m_library ); # elif defined( _WIN32 ) ::FreeLibrary( m_library ); @@ -112212,7 +112210,7 @@ namespace VULKAN_HPP_NAMESPACE template T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT { -# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) return (T)dlsym( m_library, function ); # elif defined( _WIN32 ) return ( T )::GetProcAddress( m_library, function ); @@ -112227,7 +112225,7 @@ namespace VULKAN_HPP_NAMESPACE } private: -# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) +# if defined( __linux__ ) || defined( __APPLE__ ) || defined( __QNXNTO__ ) || defined( __Fuchsia__ ) void * m_library; # elif defined( _WIN32 ) ::HINSTANCE m_library;