mirror of
https://github.com/KhronosGroup/Vulkan-Hpp.git
synced 2024-09-19 21:52:15 +00:00
Correct enum values for AccessFlagBits2KHR and PipelineStageFlagBits2KHR.
All those values erroneously started with "e2", instead of just "e".
This commit is contained in:
asuessenbach
parent
bd7a3e8ab7
commit
d9bb97d9ec
@ -405,13 +405,15 @@ std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_
|
||||
std::set<size_t> 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<size_t, size_t> const & vp ) {
|
||||
if ( vp.second != INVALID_INDEX )
|
||||
{
|
||||
skippedParams.insert( vp.second );
|
||||
}
|
||||
} );
|
||||
std::for_each( vectorParamIndices.begin(),
|
||||
vectorParamIndices.end(),
|
||||
[&skippedParams]( std::pair<size_t, size_t> 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<std::string> 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 <FlagBits>" );
|
||||
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<std::string> const & tags )
|
||||
{
|
||||
// extract the tag from the name, which is supposed to look like VK_<tag>_<other>
|
||||
@ -726,23 +705,18 @@ std::string toString( std::vector<std::string> 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<char>( 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<size_t, size_t> const & vpi ) {
|
||||
return vpi.second == i;
|
||||
} );
|
||||
it = find_if( vectorParamIndices.begin(),
|
||||
vectorParamIndices.end(),
|
||||
[i]( std::pair<size_t, size_t> 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::pair<std::string, E
|
||||
str += " enum class " + stripPrefix( enumData.first, "Vk" );
|
||||
if ( enumData.second.isBitmask )
|
||||
{
|
||||
auto bitmaskIt = std::find_if( m_bitmasks.begin(), m_bitmasks.end(), [&enumData]( auto const & bitmask ) {
|
||||
return bitmask.second.requirements == enumData.first;
|
||||
} );
|
||||
auto bitmaskIt =
|
||||
std::find_if( m_bitmasks.begin(),
|
||||
m_bitmasks.end(),
|
||||
[&enumData]( auto const & bitmask ) { return bitmask.second.requirements == enumData.first; } );
|
||||
assert( bitmaskIt != m_bitmasks.end() );
|
||||
str += " : " + bitmaskIt->first;
|
||||
}
|
||||
@ -2524,10 +2499,10 @@ void VulkanHppGenerator::appendEnum( std::string & str, std::pair<std::string, E
|
||||
{
|
||||
assert( encounteredValue );
|
||||
// make sure to only list alias values that differ from all non-alias values
|
||||
if ( std::find_if(
|
||||
enumData.second.values.begin(), enumData.second.values.end(), [&alias]( EnumValueData const & evd ) {
|
||||
return alias.second.second == evd.vkValue;
|
||||
} ) == enumData.second.values.end() )
|
||||
if ( std::find_if( enumData.second.values.begin(),
|
||||
enumData.second.values.end(),
|
||||
[&alias]( EnumValueData const & evd )
|
||||
{ return alias.second.second == evd.vkValue; } ) == enumData.second.values.end() )
|
||||
{
|
||||
#if !defined( NDEBUG )
|
||||
auto enumIt =
|
||||
@ -3150,10 +3125,10 @@ ${CppTypeFromDebugReportObjectTypeEXT}
|
||||
assert( !handleData.second.objTypeEnum.empty() );
|
||||
enumIt = m_enums.find( "VkObjectType" );
|
||||
assert( enumIt != m_enums.end() );
|
||||
valueIt = std::find_if(
|
||||
enumIt->second.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<std::string, CommandData>::const_iterator it ) {
|
||||
[constructorIt, lenIt]( std::map<std::string, CommandData>::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<Param
|
||||
else if ( param.type.isNonConstPointer() &&
|
||||
( specialPointerTypes.find( param.type.type ) == specialPointerTypes.end() ) )
|
||||
{
|
||||
// parameter is a non-const pointer (and none of the special pointer types, that are considered const-pointers, even
|
||||
// though they are not!)
|
||||
// parameter is a non-const pointer (and none of the special pointer types, that are considered const-pointers,
|
||||
// even though they are not!)
|
||||
std::string name = startLowerCase( stripPrefix( param.name, "p" ) );
|
||||
if ( param.len.empty() )
|
||||
{
|
||||
@ -5689,19 +5665,19 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique(
|
||||
{
|
||||
case 1: deleterDefinition = "ObjectDestroy<" + className + ", Dispatch> 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<std::string, StructureData> 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<std::string, HandleData> 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<std::string, HandleData> 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<std::string, StructureData> 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<std::string, StructureData> 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<std::string,
|
||||
{
|
||||
// VkBool32 is aliased to uint32_t. Don't create a VkBool32 constructor if the union also contains a uint32_t
|
||||
// constructor.
|
||||
auto compareBool32Alias = []( MemberData const & member ) {
|
||||
auto compareBool32Alias = []( MemberData const & member )
|
||||
{
|
||||
return member.type.type == std::string( "uint32_t" );
|
||||
};
|
||||
if ( member.type.type == "VkBool32" )
|
||||
@ -10664,10 +10642,11 @@ void VulkanHppGenerator::appendUnion( std::string & str, std::pair<std::string,
|
||||
|
||||
// the union member variables
|
||||
// if there's at least one Vk... type in this union, check for unrestricted unions support
|
||||
bool needsUnrestrictedUnions =
|
||||
( std::find_if( structure.second.members.begin(), structure.second.members.end(), []( MemberData const & member ) {
|
||||
return beginsWith( member.type.type, "Vk" );
|
||||
} ) != structure.second.members.end() );
|
||||
bool needsUnrestrictedUnions = ( std::find_if( structure.second.members.begin(),
|
||||
structure.second.members.end(),
|
||||
[]( MemberData const & member ) {
|
||||
return beginsWith( member.type.type, "Vk" );
|
||||
} ) != structure.second.members.end() );
|
||||
if ( needsUnrestrictedUnions )
|
||||
{
|
||||
str += "#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS\n";
|
||||
@ -10743,8 +10722,8 @@ void VulkanHppGenerator::EnumData::addEnumAlias( int line,
|
||||
// check that the aliasName is either a known enum value or at least a known alias
|
||||
check( ( std::find_if( values.begin(),
|
||||
values.end(),
|
||||
[&aliasName]( EnumValueData const & evd ) { return evd.vulkanValue == aliasName; } ) !=
|
||||
values.end() ) ||
|
||||
[&aliasName]( EnumValueData const & evd )
|
||||
{ return evd.vulkanValue == aliasName; } ) != values.end() ) ||
|
||||
( aliases.find( aliasName ) != aliases.end() ),
|
||||
line,
|
||||
"unknown enum alias <" + aliasName + ">" );
|
||||
@ -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<std::string, std::pair<std::string, std::string>> const & aliasEntry ) {
|
||||
return vkName == aliasEntry.second.second;
|
||||
} );
|
||||
[&vkName]( std::pair<std::string, std::pair<std::string, std::string>> 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<std::string, HandleData> const & hd ) {
|
||||
return hd.second.objTypeEnum == objectTypeValue.vulkanValue;
|
||||
} ) != m_handles.end(),
|
||||
[&objectTypeValue]( std::pair<std::string, HandleData> 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<std::map<std::string, VulkanHppGenerator::CommandData>::const_iterat
|
||||
for ( auto commandIt = m_commands.begin(); commandIt != m_commands.end(); )
|
||||
{
|
||||
commandIt =
|
||||
std::find_if( commandIt, m_commands.end(), [&handleType]( std::pair<std::string, CommandData> 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<std::string, CommandData> 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<std::map<std::string, VulkanHppGenerator::CommandData>::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<std::map<std::string, VulkanHppGenerator::CommandData>::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<size_t, size_t> const & vpi ) {
|
||||
return vpi.second == index;
|
||||
} ) == vectorParamIndices.end() );
|
||||
assert( std::find_if( vectorParamIndices.begin(),
|
||||
vectorParamIndices.end(),
|
||||
[index]( std::pair<size_t, size_t> const & vpi )
|
||||
{ return vpi.second == index; } ) == vectorParamIndices.end() );
|
||||
|
||||
std::map<size_t, size_t>::const_iterator vpit = vectorParamIndices.find( index );
|
||||
if ( ( vpit == vectorParamIndices.end() ) || twoStep || ( vectorParamIndices.size() > 1 ) ||
|
||||
@ -11350,9 +11332,10 @@ std::map<size_t, size_t>
|
||||
{
|
||||
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 <FlagBits>" );
|
||||
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<std::string> VulkanHppGenerator::getPlatforms( std::set<std::string> const & extensions ) const
|
||||
{
|
||||
std::set<std::string> platforms;
|
||||
@ -11666,9 +11675,10 @@ std::pair<std::string, std::string> 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<ParamData> 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<size_t, size_t> 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<size_t, size_t> 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<std::string, HandleData> const & hd ) {
|
||||
return hd.second.alias == type;
|
||||
} );
|
||||
it = std::find_if( m_handles.begin(),
|
||||
m_handles.end(),
|
||||
[&type]( std::pair<std::string, HandleData> 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<std::string, StructureData> 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<std::string, StructureData> const & sd )
|
||||
{ return sd.second.aliases.find( type ) != sd.second.aliases.end(); } );
|
||||
}
|
||||
if ( it != m_structures.end() )
|
||||
{
|
||||
@ -11855,8 +11865,8 @@ std::pair<bool, std::map<size_t, std::vector<size_t>>>
|
||||
}
|
||||
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<std::string, std::string> const & nameNumber ) {
|
||||
return nameNumber.second == requiresCore;
|
||||
} ) != m_features.end(),
|
||||
[&requiresCore]( std::pair<std::string, std::string> 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<std::string, PlatformData> const & p ) {
|
||||
return p.second.protect == protect;
|
||||
} ) == m_platforms.end(),
|
||||
[&protect]( std::pair<std::string, PlatformData> 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<std::string> mutualExclusiveStructs = { "VkAccelerationStructureBuildGeometryInfoKHR",
|
||||
"VkWriteDescriptorSet" };
|
||||
static std::set<std::string> multipleLenStructs = { "VkImageConstraintsInfoFUCHSIA",
|
||||
|
||||
@ -971,7 +971,9 @@ private:
|
||||
std::string const & structName,
|
||||
std::string const & prefix,
|
||||
bool mutualExclusiveLens ) const;
|
||||
std::set<std::string> getPlatforms( std::set<std::string> const & extensions ) const;
|
||||
std::string getEnumPrefix( int line, std::string const & name, bool bitmask ) const;
|
||||
std::set<std::string> getPlatforms(
|
||||
std::set<std::string> const & extensions ) const;
|
||||
std::pair<std::string, std::string> getPoolTypeAndName( std::string const & type ) const;
|
||||
std::string getVectorSize( std::vector<ParamData> const & params,
|
||||
std::map<size_t, size_t> const & vectorParamIndices,
|
||||
|
||||
@ -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 <dlfcn.h>
|
||||
# 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<uint32_t>( 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<uint32_t>( 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<T>( result, data );
|
||||
return ResultValue<T>( 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 <typename T>
|
||||
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;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user