TheCloud/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2025-09-10 12:28:48 -04:00
Code Issues Packages Projects Releases Wiki Activity

Refactor commands enumerating some non-handle, non-StructureChain data type.

Browse Source
This commit is contained in:
asuessenbach 2020-10-20 12:27:08 +02:00
parent 32c994335a
commit 75ce35813d
3 changed files with 1176 additions and 945 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

444
VulkanHppGenerator.cpp
View File

@ -57,7 +57,6 @@ std::string createEnumValueName( std::string const & name,
std::string createSuccessCode( std::string const & code, std::set<std::string> const & tags ); std::string createSuccessCode( std::string const & code, std::set<std::string> const & tags );
std::string determineCommandName( std::string const & vulkanCommandName, std::string const & firstArgumentType ); std::string determineCommandName( std::string const & vulkanCommandName, std::string const & firstArgumentType );
std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices ); std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_t, size_t> const & vectorParamIndices );
bool determineStructureChaining( std::string const & structType, std::set<std::string> const & extendedStructs );
std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags ); std::string extractTag( int line, std::string const & name, std::set<std::string> const & tags );
std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" ); std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix = "" );
std::pair<bool, std::string> generateFunctionBodyStandardReturn( std::string const & returnType ); std::pair<bool, std::string> generateFunctionBodyStandardReturn( std::string const & returnType );
@ -391,11 +390,6 @@ std::set<size_t> determineSkippedParams( size_t returnParamIndex, std::map<size_
return skippedParams; return skippedParams;
} }
bool determineStructureChaining( std::string const & structType, std::set<std::string> const & extendedStructs )
{
return ( extendedStructs.find( structType ) != extendedStructs.end() );
}
std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix ) std::string findTag( std::set<std::string> const & tags, std::string const & name, std::string const & postfix )
{ {
auto tagIt = std::find_if( auto tagIt = std::find_if(
@ -858,7 +852,7 @@ void VulkanHppGenerator::appendArguments( std::string & str,
} }
else if ( beginsWith( commandData.params[i].type.type, "Vk" ) ) else if ( beginsWith( commandData.params[i].type.type, "Vk" ) )
{ {
appendArgumentVulkanType( str, commandData.params[i] ); str += "static_cast<" + commandData.params[i].type.type + ">( " + commandData.params[i].name + " )";
} }
else else
{ {
@ -895,12 +889,6 @@ void VulkanHppGenerator::appendArgumentVector( std::string & str,
appendReinterpretCast( str, paramData.type.prefix.find( "const" ) == 0, paramData.type.type ); appendReinterpretCast( str, paramData.type.prefix.find( "const" ) == 0, paramData.type.type );
str += "( " + parameterName + ".data() )"; str += "( " + parameterName + ".data() )";
} }
else if ( paramData.type.type == "char" )
{
// the parameter is a vector to char -> it might be optional
// besides that, the parameter now is a std::string -> get the pointer via c_str()
str += parameterName + ( paramData.optional ? ( " ? " + parameterName + "->c_str() : nullptr" ) : ".c_str()" );
}
else else
{ {
// this parameter is just a vetor -> get the pointer to its data // this parameter is just a vetor -> get the pointer to its data
@ -909,27 +897,6 @@ void VulkanHppGenerator::appendArgumentVector( std::string & str,
} }
} }
void VulkanHppGenerator::appendArgumentVulkanType( std::string & str, ParamData const & paramData ) const
{
// this parameter is a vulkan type
if ( !paramData.type.postfix.empty() || !paramData.arraySizes.empty() )
{
assert( ( paramData.type.postfix.empty() || ( paramData.type.postfix.back() == '*' ) ) &&
( paramData.arraySizes.empty() || ( paramData.arraySizes.size() == 1 ) ) );
// it's a pointer -> needs a reinterpret cast to the vulkan type
std::string parameterName = startLowerCase( stripPrefix( paramData.name, "p" ) );
appendReinterpretCast( str, paramData.type.prefix.find( "const" ) != std::string::npos, paramData.type.type );
assert( !paramData.optional );
// those parameters can just use the pointer
str += std::string( "( " ) + ( paramData.arraySizes.empty() ? "&" : "" ) + parameterName + " )";
}
else
{
// a non-pointer parameter needs a static_cast from VULKAN_HPP_NAMESPACE-type to vulkan type
str += "static_cast<" + paramData.type.type + ">( " + paramData.name + " )";
}
}
void VulkanHppGenerator::appendBaseTypes( std::string & str ) const void VulkanHppGenerator::appendBaseTypes( std::string & str ) const
{ {
assert( !m_baseTypes.empty() ); assert( !m_baseTypes.empty() );
@ -1267,38 +1234,48 @@ void VulkanHppGenerator::appendCommand( std::string & str,
break; break;
case 2: case 2:
// two return parameters // two return parameters
switch ( vectorParamIndices.size() ) if ( !isHandleType( commandData.params[nonConstPointerParamIndices[0]].type.type ) &&
!isHandleType( commandData.params[nonConstPointerParamIndices[1]].type.type ) &&
!isStructureChainAnchor( commandData.params[nonConstPointerParamIndices[0]].type.type ) &&
!isStructureChainAnchor( commandData.params[nonConstPointerParamIndices[1]].type.type ) )
{ {
case 1: // non of the return parameters is a handle or a StructureChain
switch ( vectorParamIndices.size() )
{ {
// two returns but just one vector -> the size is a return value as well -> enumerate the values case 1:
auto vectorParamIndexIt = vectorParamIndices.begin();
assert( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) &&
( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) );
if ( ( commandData.returnType == "void" ) &&
!determineStructureChaining( commandData.params[vectorParamIndexIt->first].type.type,
m_extendedStructs ) )
{ {
assert( commandData.params[vectorParamIndexIt->first].type.type != "void" ); // two returns but just one vector
// provide standard, enhanced, and vector calls auto vectorParamIndexIt = vectorParamIndices.begin();
appendCommandVector( str, name, commandData, *vectorParamIndexIt, definition ); if ( ( vectorParamIndexIt->second == nonConstPointerParamIndices[0] ) &&
( vectorParamIndexIt->first == nonConstPointerParamIndices[1] ) &&
( commandData.params[vectorParamIndexIt->first].type.type != "void" ) )
{
// 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, *vectorParamIndexIt, definition );
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
assert( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() );
assert( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() );
assert( commandData.returnType == "VkResult" );
// provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls
appendCommandStandardEnhancedDeprecatedAllocator(
str, name, commandData, definition, vectorParamIndices, nonConstPointerParamIndices );
appendedFunction = true; appendedFunction = true;
} }
break;
default: break;
} }
break;
case 2:
{
// two returns and two vectors! But one input vector, one output vector of the same size, and one output value
assert( vectorParamIndices.find( nonConstPointerParamIndices[0] ) != vectorParamIndices.end() );
assert( vectorParamIndices.find( nonConstPointerParamIndices[1] ) == vectorParamIndices.end() );
assert( commandData.returnType == "VkResult" );
// provide standard, enhanced deprecated, enhanced, and enhanced with allocator calls
appendCommandStandardEnhancedDeprecatedAllocator(
str, name, commandData, definition, vectorParamIndices, nonConstPointerParamIndices );
appendedFunction = true;
}
break;
default: break;
} }
break; break;
case 3: case 3:
@ -1355,11 +1332,10 @@ void VulkanHppGenerator::appendCommand( std::string & str,
size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep ); size_t returnParamIndex = determineReturnParamIndex( commandData, vectorParamIndices, twoStep );
bool isStructureChain = bool isStructureChain =
( returnParamIndex != INVALID_INDEX ) && ( returnParamIndex != INVALID_INDEX ) &&
determineStructureChaining( commandData.params[returnParamIndex].type.type, m_extendedStructs ); ( m_extendedStructs.find( commandData.params[returnParamIndex].type.type ) != m_extendedStructs.end() );
std::string enhancedReturnType = std::string enhancedReturnType =
determineEnhancedReturnType( commandData, determineEnhancedReturnType( commandData,
returnParamIndex, returnParamIndex,
vectorParamIndices,
false ); // get the enhanced return type without structureChain false ); // get the enhanced return type without structureChain
size_t templateParamIndex = determineTemplateParamIndex( commandData.params, vectorParamIndices ); size_t templateParamIndex = determineTemplateParamIndex( commandData.params, vectorParamIndices );
@ -1416,7 +1392,7 @@ void VulkanHppGenerator::appendCommand( std::string & str,
if ( isStructureChain ) if ( isStructureChain )
{ {
std::string enhancedReturnTypeWithStructureChain = std::string enhancedReturnTypeWithStructureChain =
determineEnhancedReturnType( commandData, returnParamIndex, vectorParamIndices, true ); determineEnhancedReturnType( commandData, returnParamIndex, true );
appendFunction( enhanced, appendFunction( enhanced,
indentation, indentation,
name, name,
@ -1472,16 +1448,7 @@ void VulkanHppGenerator::appendCommand( std::string & str,
// standard and enhanced string differ -> use both, wrapping the enhanced by !VULKAN_HPP_DISABLE_ENHANCED_MODE // standard and enhanced string differ -> use both, wrapping the enhanced by !VULKAN_HPP_DISABLE_ENHANCED_MODE
// determine the argument list of that standard, and compare it with that of the enhanced // determine the argument list of that standard, and compare it with that of the enhanced
// if they are equal -> need to have just one; if they differ -> need to have both // if they are equal -> need to have just one; if they differ -> need to have both
size_t standardStart = standard.find( '(' ); str += standard + "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" + "\n" + enhanced +
size_t standardCount = standard.find( ')', standardStart ) - standardStart;
size_t enhancedStart = enhanced.find( '(' );
bool unchangedInterface =
( standard.substr( standardStart, standardCount ) == enhanced.substr( enhancedStart, standardCount ) );
if ( unchangedInterface )
{
str += "#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE\n";
}
str += standard + ( unchangedInterface ? "#else" : "#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE" ) + "\n" + enhanced +
"#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/\n"; "#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/\n";
} }
str += leave; str += leave;
@ -1588,11 +1555,10 @@ ${leave})";
std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
str += replaceWithMap( functionTemplate, str += replaceWithMap( functionTemplate,
std::map<std::string, std::string>( { std::map<std::string, std::string>(
{ "commandStandard", constructCommandStandard( name, commandData, definition ) }, { { "commandStandard", constructCommandStandard( name, commandData, definition ) },
{ "enter", enter }, { "enter", enter },
{ "leave", leave } { "leave", leave } } ) );
} ) );
} }
void VulkanHppGenerator::appendCommandStandardAndEnhanced( void VulkanHppGenerator::appendCommandStandardAndEnhanced(
@ -1766,28 +1732,34 @@ void VulkanHppGenerator::appendCommandVector( std::string &
std::pair<size_t, size_t> const & vectorParamIndex, std::pair<size_t, size_t> const & vectorParamIndex,
bool definition ) const bool definition ) const
{ {
assert( commandData.returnType == "void" ); assert( ( commandData.returnType == "VkResult" ) || ( commandData.returnType == "void" ) );
std::string enter, leave; std::string enter, leave;
std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions ); std::tie( enter, leave ) = generateProtection( commandData.feature, commandData.extensions );
assert( enter.empty() );
const std::string functionTemplate = R"( const std::string functionTemplate = R"(
${commandStandard}${newlineOnDefinition} ${enter}${commandStandard}${newlineOnDefinition}
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
${commandEnhanced}${newlineOnDefinition} ${commandEnhanced}${newlineOnDefinition}
${commandEnhancedWithAllocators} ${commandEnhancedWithAllocators}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
)"; ${leave})";
str += replaceWithMap( str +=
functionTemplate, replaceWithMap( functionTemplate,
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "commandEnhanced", constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, false ) }, { { "commandEnhanced",
{ "commandEnhancedWithAllocators", ( commandData.returnType == "VkResult" )
constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, true ) }, ? constructCommandResultEnumerate( name, commandData, definition, vectorParamIndex, false )
{ "commandStandard", constructCommandStandard( name, commandData, definition ) }, : constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, false ) },
{ "newlineOnDefinition", definition ? "\n" : "" } } ) ); { "commandEnhancedWithAllocators",
( commandData.returnType == "VkResult" )
? constructCommandResultEnumerate( name, commandData, definition, vectorParamIndex, true )
: constructCommandVoidEnumerate( name, commandData, definition, vectorParamIndex, true ) },
{ "commandStandard", constructCommandStandard( name, commandData, definition ) },
{ "enter", enter },
{ "leave", leave },
{ "newlineOnDefinition", definition ? "\n" : "" } } ) );
} }
void VulkanHppGenerator::appendCommandVectorDeprecated( std::string & str, void VulkanHppGenerator::appendCommandVectorDeprecated( std::string & str,
@ -2826,9 +2798,7 @@ bool VulkanHppGenerator::appendFunctionHeaderArgumentEnhanced( std::string &
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool skip, bool skip,
bool argEncountered, bool argEncountered,
bool isTemplateParam, bool isTemplateParam ) const
bool withDefaults,
bool withAllocator ) const
{ {
if ( !skip ) if ( !skip )
{ {
@ -2858,7 +2828,7 @@ bool VulkanHppGenerator::appendFunctionHeaderArgumentEnhanced( std::string &
{ {
// the argument is a vector // the argument is a vector
appendFunctionHeaderArgumentEnhancedVector( appendFunctionHeaderArgumentEnhancedVector(
str, param, strippedParameterName, it->second != INVALID_INDEX, isTemplateParam, withDefaults, withAllocator ); str, param, strippedParameterName, it->second != INVALID_INDEX, isTemplateParam );
} }
argEncountered = true; argEncountered = true;
} }
@ -2881,36 +2851,20 @@ void VulkanHppGenerator::appendFunctionHeaderArgumentEnhancedVector( std::string
ParamData const & param, ParamData const & param,
std::string const & strippedParameterName, std::string const & strippedParameterName,
bool hasSizeParam, bool hasSizeParam,
bool isTemplateParam, bool isTemplateParam ) const
bool withDefaults,
bool withAllocator ) const
{ {
assert( param.type.postfix.back() == '*' ); assert( param.type.postfix.back() == '*' );
// it's optional, if it's marked as optional and there's no size specified // it's optional, if it's marked as optional and there's no size specified
bool optional = param.optional && !hasSizeParam; bool optional = param.optional && !hasSizeParam;
bool useString = ( param.type.type.find( "char" ) != std::string::npos );
std::string optionalBegin = optional ? "Optional<" : ""; std::string optionalBegin = optional ? "Optional<" : "";
std::string optionalEnd = optional ? "> " : ( useString ? " & " : "" ); std::string optionalEnd = optional ? "> " : "";
if ( useString ) // use our ArrayProxy
{ bool isConst = ( param.type.prefix.find( "const" ) != std::string::npos );
// it's a char-vector -> use a std::string str += optionalBegin + "ArrayProxy<" +
assert( param.type.prefix.find( "const" ) != std::string::npos ); ( isTemplateParam ? ( isConst ? "const T" : "T" ) : stripPostfix( param.type.compose(), "*" ) ) +
str += optionalBegin + "const std::string" + optionalEnd + strippedParameterName; "> const &" + optionalEnd + strippedParameterName;
if ( optional && withDefaults && !withAllocator )
{
str += " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT";
}
}
else
{
// otherwise, use our ArrayProxy
bool isConst = ( param.type.prefix.find( "const" ) != std::string::npos );
str += optionalBegin + "ArrayProxy<" +
( isTemplateParam ? ( isConst ? "const T" : "T" ) : stripPostfix( param.type.compose(), "*" ) ) +
"> const &" + optionalEnd + strippedParameterName;
}
} }
void VulkanHppGenerator::appendFunctionHeaderArguments( std::string & str, void VulkanHppGenerator::appendFunctionHeaderArguments( std::string & str,
@ -2957,7 +2911,7 @@ void VulkanHppGenerator::appendFunctionHeaderReturnType( std::string & str
CommandData const & commandData, CommandData const & commandData,
size_t size_t
#if !defined( NDEBUG ) #if !defined( NDEBUG )
returnParamIndex returnParamIndex
#endif #endif
, ,
std::string const & enhancedReturnType, std::string const & enhancedReturnType,
@ -3582,7 +3536,7 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
bool definition, bool definition,
bool withAllocators ) const bool withAllocators ) const
{ {
size_t defaultStartIndex = determineDefaultStartIndex( params, skippedParams ); size_t defaultStartIndex = withAllocators ? ~0 : determineDefaultStartIndex( params, skippedParams );
std::string argumentList; std::string argumentList;
for ( size_t i = 0; i < params.size(); ++i ) for ( size_t i = 0; i < params.size(); ++i )
@ -3599,6 +3553,7 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
} }
else if ( params[i].type.isConstPointer() ) else if ( params[i].type.isConstPointer() )
{ {
std::string name = startLowerCase( stripPrefix( params[i].name, "p" ) );
if ( params[i].len.empty() ) if ( params[i].len.empty() )
{ {
assert( !params[i].type.prefix.empty() && ( params[i].type.postfix == "*" ) ); assert( !params[i].type.prefix.empty() && ( params[i].type.postfix == "*" ) );
@ -3611,15 +3566,13 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
{ {
argumentList += argumentList +=
"Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " + "Optional<const " + stripPrefix( params[i].type.type, "Vk" ) + "> " +
startLowerCase( name +
stripPrefix( params[i].name, "p" ) + ( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" );
( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" ) );
hasDefaultAssignment = true; hasDefaultAssignment = true;
} }
else else
{ {
argumentList += params[i].type.prefix + " " + stripPrefix( params[i].type.type, "Vk" ) + " & " + argumentList += params[i].type.prefix + " " + stripPrefix( params[i].type.type, "Vk" ) + " & " + name;
startLowerCase( stripPrefix( params[i].name, "p" ) );
} }
} }
else else
@ -3628,7 +3581,17 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
if ( params[i].len == "null-terminated" ) if ( params[i].len == "null-terminated" )
{ {
assert( params[i].type.type == "char" ); assert( params[i].type.type == "char" );
argumentList += "const std::string & "; if ( params[i].optional )
{
argumentList +=
"Optional<const std::string> " + name +
( ( definition || withAllocators ) ? "" : " VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT" );
hasDefaultAssignment = true;
}
else
{
argumentList += "const std::string & " + name;
}
} }
else else
{ {
@ -3641,9 +3604,8 @@ std::string VulkanHppGenerator::constructArgumentListEnhanced( std::vector<Param
type.replace( pos, 4, "T" ); type.replace( pos, 4, "T" );
} }
argumentList += "ArrayProxy<" + type + "> const & "; argumentList += "ArrayProxy<" + type + "> const & " + name;
} }
argumentList += startLowerCase( stripPrefix( params[i].name, "p" ) );
} }
} }
else if ( params[i].type.isNonConstPointer() ) else if ( params[i].type.isNonConstPointer() )
@ -3714,7 +3676,8 @@ std::string VulkanHppGenerator::constructCallArgument( ParamData const & param,
assert( !param.type.isValue() ); assert( !param.type.isValue() );
assert( param.type.type == "char" ); assert( param.type.type == "char" );
assert( beginsWith( param.name, "p" ) ); assert( beginsWith( param.name, "p" ) );
argument = startLowerCase( stripPrefix( param.name, "p" ) ) + ".c_str()"; argument = startLowerCase( stripPrefix( param.name, "p" ) );
argument = param.optional ? ( argument + " ? " + argument + "->c_str() : nullptr" ) : ( argument + ".c_str()" );
} }
else if ( enhanced && ( param.type.type == "Display" ) ) else if ( enhanced && ( param.type.type == "Display" ) )
{ {
@ -3761,17 +3724,28 @@ std::string VulkanHppGenerator::constructCallArgument( ParamData const & param,
} }
std::string std::string
VulkanHppGenerator::constructCallArgumentsEnumerateVectors( std::vector<ParamData> const & params, VulkanHppGenerator::constructCallArgumentsEnumerateVectors( std::string const & handle,
std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool vectorAsNullptr ) const bool vectorAsNullptr ) const
{ {
size_t countIndex = vectorParamIndices.begin()->second; size_t countIndex = vectorParamIndices.begin()->second;
assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) ); assert( ( vectorParamIndices.size() != 2 ) || ( std::next( vectorParamIndices.begin() )->second == countIndex ) );
std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); std::string arguments;
for ( size_t i = 1; i < params.size(); i++ ) size_t i = 0;
if ( !handle.empty() )
{ {
arguments += ", "; assert( handle == params[0].type.type );
arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) );
++i;
}
for ( ; i < params.size(); i++ )
{
if ( 0 < i )
{
arguments += ", ";
}
if ( i == countIndex ) if ( i == countIndex )
{ {
assert( !params[i].type.isValue() ); assert( !params[i].type.isValue() );
@ -3835,13 +3809,21 @@ std::string VulkanHppGenerator::constructCallArgumentsGetValue( std::string cons
return arguments; return arguments;
} }
std::string VulkanHppGenerator::constructCallArgumentsGetVector( std::vector<ParamData> const & params, std::string VulkanHppGenerator::constructCallArgumentsGetVector( std::string const & handle,
std::vector<ParamData> const & params,
std::vector<size_t> const & returnParamIndices, std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool singular ) const bool singular ) const
{ {
std::string arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) ); std::string arguments;
for ( size_t i = 1; i < params.size(); i++ ) size_t i = 0;
if ( !handle.empty() )
{
assert( handle == params[0].type.type );
arguments = "m_" + startLowerCase( stripPrefix( params[0].type.type, "Vk" ) );
++i;
}
for ( ; i < params.size(); i++ )
{ {
arguments += ", "; arguments += ", ";
auto vpiIt = vectorParamIndices.find( i ); auto vpiIt = vectorParamIndices.find( i );
@ -4041,6 +4023,104 @@ std::string VulkanHppGenerator::constructCommandResult( std::string const &
return str; return str;
} }
std::string VulkanHppGenerator::constructCommandResultEnumerate( std::string const & name,
CommandData const & commandData,
bool definition,
std::pair<size_t, size_t> const & vectorParamIndices,
bool withAllocator ) const
{
assert( commandData.returnType == "VkResult" );
assert( ( commandData.successCodes.size() == 2 ) && ( commandData.successCodes[0] == "VK_SUCCESS" ) &&
( commandData.successCodes[1] == "VK_INCOMPLETE" ) );
std::string str;
std::set<size_t> skippedParams = determineSkippedParams( commandData.handle,
commandData.params,
{ vectorParamIndices },
{ vectorParamIndices.second, vectorParamIndices.first } );
std::string argumentList =
constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator );
std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string nodiscard = constructNoDiscardEnhanced( commandData );
std::string vectorElementType = stripPrefix( commandData.params[vectorParamIndices.first].type.type, "Vk" );
if ( definition )
{
const std::string functionTemplate =
R"( template <typename ${vectorElementType}Allocator, typename Dispatch${withAllocatorTypenameCheck}>
${nodiscard}VULKAN_HPP_INLINE typename ResultValueType<std::vector<${vectorElementType}, ${vectorElementType}Allocator>>::type ${className}${commandName}( ${argumentList} )${const}
{
std::vector<${vectorElementType}, ${vectorElementType}Allocator> ${vectorName}${vectorAllocator};
${counterType} ${counterName};
Result result;
do
{
result = static_cast<Result>( d.${vkCommand}( ${firstCallArguments} ) );
if ( ( result == Result::eSuccess ) && ${counterName} )
{
${vectorName}.resize( ${counterName} );
result = static_cast<Result>( d.${vkCommand}( ${secondCallArguments} ) );
VULKAN_HPP_ASSERT( ${counterName} <= ${vectorName}.size() );
}
} while ( result == Result::eIncomplete );
if ( ( result == Result::eSuccess ) && ( ${counterName} < ${vectorName}.size() ) )
{
${vectorName}.resize( ${counterName} );
}
return createResultValue( result, ${vectorName}, VULKAN_HPP_NAMESPACE_STRING"::${className}${commandName}" );
})";
std::string withAllocatorsTypenameCheck =
", typename B, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
">::value, int>::type ";
str = replaceWithMap(
functionTemplate,
std::map<std::string, std::string>(
{ { "argumentList", argumentList },
{ "className", commandData.handle.empty() ? "" : ( stripPrefix( commandData.handle, "Vk" ) + "::" ) },
{ "commandName", commandName },
{ "const", commandData.handle.empty() ? "" : " const" },
{ "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.second].name, "p" ) ) },
{ "counterType", commandData.params[vectorParamIndices.second].type.type },
{ "firstCallArguments",
constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, { vectorParamIndices }, true ) },
{ "nodiscard", nodiscard },
{ "secondCallArguments",
constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, { vectorParamIndices }, false ) },
{ "vectorAllocator", withAllocator ? ( "( " + startLowerCase( vectorElementType ) + "Allocator )" ) : "" },
{ "vectorElementType", vectorElementType },
{ "vectorName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.first].name, "p" ) ) },
{ "vkCommand", name },
{ "withAllocatorTypenameCheck", withAllocator ? withAllocatorsTypenameCheck : "" } } ) );
}
else
{
const std::string functionTemplate =
R"( template <typename ${vectorElementType}Allocator = std::allocator<${vectorElementType}>, typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE${withAllocatorTypenameCheck}>
${nodiscard}typename ResultValueType<std::vector<${vectorElementType}, ${vectorElementType}Allocator>>::type ${commandName}( ${argumentList} )${const};)";
std::string withAllocatorsTypenameCheck =
", typename B = " + vectorElementType +
"Allocator, typename std::enable_if<std::is_same<typename B::value_type, " + vectorElementType +
">::value, int>::type = 0";
str = replaceWithMap( functionTemplate,
std::map<std::string, std::string>(
{ { "argumentList", argumentList },
{ "const", commandData.handle.empty() ? "" : " const" },
{ "commandName", commandName },
{ "nodiscard", nodiscard },
{ "vectorElementType", vectorElementType },
{ "withAllocatorTypenameCheck", withAllocator ? withAllocatorsTypenameCheck : "" } } ) );
}
return str;
}
std::string std::string
VulkanHppGenerator::constructCommandResultEnumerateTwoVectors( std::string const & name, VulkanHppGenerator::constructCommandResultEnumerateTwoVectors( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
@ -4118,7 +4198,8 @@ std::string
startLowerCase( stripPrefix( stripPluralS( commandData.params[firstVectorParamIt->second].name ), "p" ) ) }, startLowerCase( stripPrefix( stripPluralS( commandData.params[firstVectorParamIt->second].name ), "p" ) ) },
{ "counterType", commandData.params[firstVectorParamIt->second].type.type }, { "counterType", commandData.params[firstVectorParamIt->second].type.type },
{ "firstCallArguments", { "firstCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, true ) }, constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, vectorParamIndices, true ) },
{ "firstVectorName", { "firstVectorName",
startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ) }, startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ) },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
@ -4131,7 +4212,8 @@ std::string
"Allocator ) )" ) "Allocator ) )" )
: "" }, : "" },
{ "secondCallArguments", { "secondCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, vectorParamIndices, false ) }, constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, vectorParamIndices, false ) },
{ "secondVectorName", { "secondVectorName",
startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ) }, startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ) },
{ "templateTypeFirst", templateTypeFirst }, { "templateTypeFirst", templateTypeFirst },
@ -4177,7 +4259,7 @@ std::string VulkanHppGenerator::constructCommandResultEnumerateTwoVectorsDepreca
commandData, returnParamIndex, returnParamIndex, vectorParamIndices, !definition, withAllocators ); commandData, returnParamIndex, returnParamIndex, vectorParamIndices, !definition, withAllocators );
std::string commandName = determineCommandName( name, commandData.params[0].type.type ); std::string commandName = determineCommandName( name, commandData.params[0].type.type );
std::string nodiscard = constructNoDiscardEnhanced( commandData ); std::string nodiscard = constructNoDiscardEnhanced( commandData );
std::string returnType = determineEnhancedReturnType( commandData, returnParamIndex, vectorParamIndices, false ); std::string returnType = determineEnhancedReturnType( commandData, returnParamIndex, false );
std::string templateType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ); std::string templateType = stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" );
if ( definition ) if ( definition )
@ -4406,7 +4488,7 @@ std::string
std::string str; std::string str;
auto firstVectorParamIt = vectorParamIndices.begin(); auto firstVectorParamIt = vectorParamIndices.begin();
assert( commandData.params[0].type.type == commandData.handle ); assert( commandData.params[0].type.type == commandData.handle );
@ -4637,7 +4719,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVector( std::string con
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) },
@ -4719,7 +4802,8 @@ std::string
{ "allocatorType", allocatorType }, { "allocatorType", allocatorType },
{ "argumentList", argumentList }, { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, returnParamIndices, vectorParamIndices, false ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, returnParamIndices, vectorParamIndices, false ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
@ -4831,7 +4915,7 @@ std::string
std::string str; std::string str;
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } );
std::string argumentList = std::string argumentList =
constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator ); constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator );
@ -4863,7 +4947,8 @@ std::string
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
@ -4914,7 +4999,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesSingular
std::string str; std::string str;
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } );
size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first ) size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first )
? std::next( vectorParamIndices.begin() )->first ? std::next( vectorParamIndices.begin() )->first
: vectorParamIndices.begin()->first; : vectorParamIndices.begin()->first;
@ -4944,7 +5029,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesSingular
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
@ -4984,7 +5070,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique(
std::string str; std::string str;
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } );
std::string argumentList = std::string argumentList =
constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator ); constructArgumentListEnhanced( commandData.params, skippedParams, INVALID_INDEX, definition, withAllocator );
@ -5052,7 +5138,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUnique(
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, false ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, false ) },
{ "className", className }, { "className", className },
{ "commandName", commandName }, { "commandName", commandName },
{ "deleterDefinition", deleterDefinition }, { "deleterDefinition", deleterDefinition },
@ -5107,7 +5194,7 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUniqueSi
std::string str; std::string str;
std::set<size_t> skippedParams = std::set<size_t> skippedParams =
determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ); determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } );
size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first ) size_t singularParam = ( returnParamIndex == vectorParamIndices.begin()->first )
? std::next( vectorParamIndices.begin() )->first ? std::next( vectorParamIndices.begin() )->first
: vectorParamIndices.begin()->first; : vectorParamIndices.begin()->first;
@ -5138,7 +5225,8 @@ std::string VulkanHppGenerator::constructCommandResultGetVectorOfHandlesUniqueSi
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "handleName", { "handleName",
@ -5180,7 +5268,7 @@ std::string
std::string argumentList = constructArgumentListEnhanced( std::string argumentList = constructArgumentListEnhanced(
commandData.params, commandData.params,
determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, returnParamIndex ), determineSkippedParams( commandData.handle, commandData.params, vectorParamIndices, { returnParamIndex } ),
INVALID_INDEX, INVALID_INDEX,
definition, definition,
false ); false );
@ -5204,7 +5292,8 @@ std::string
std::map<std::string, std::string>( std::map<std::string, std::string>(
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
constructCallArgumentsGetVector( commandData.params, { returnParamIndex }, vectorParamIndices, true ) }, constructCallArgumentsGetVector(
commandData.handle, commandData.params, { returnParamIndex }, vectorParamIndices, true ) },
{ "className", stripPrefix( commandData.handle, "Vk" ) }, { "className", stripPrefix( commandData.handle, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) }, { "dataName", startLowerCase( stripPrefix( commandData.params[returnParamIndex].name, "p" ) ) },
@ -5532,9 +5621,11 @@ std::string VulkanHppGenerator::constructCommandVoidEnumerate( std::string const
{ "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.second].name, "p" ) ) }, { "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndex.second].name, "p" ) ) },
{ "counterType", commandData.params[vectorParamIndex.second].type.type }, { "counterType", commandData.params[vectorParamIndex.second].type.type },
{ "firstCallArguments", { "firstCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, true ) }, constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, { vectorParamIndex }, true ) },
{ "secondCallArguments", { "secondCallArguments",
constructCallArgumentsEnumerateVectors( commandData.params, { vectorParamIndex }, false ) }, constructCallArgumentsEnumerateVectors(
commandData.handle, commandData.params, { vectorParamIndex }, false ) },
{ "typenameCheck", withAllocators ? typenameCheck : "" }, { "typenameCheck", withAllocators ? typenameCheck : "" },
{ "vectorAllocator", { "vectorAllocator",
withAllocators withAllocators
@ -5769,9 +5860,7 @@ std::string
vectorParamIndices, vectorParamIndices,
skippedParams.find( i ) != skippedParams.end(), skippedParams.find( i ) != skippedParams.end(),
argEncountered, argEncountered,
( templateParamIndex == i ), ( templateParamIndex == i ) );
withDefaults,
withAllocator );
} }
if ( argEncountered ) if ( argEncountered )
@ -7128,17 +7217,10 @@ size_t VulkanHppGenerator::determineDefaultStartIndex( std::vector<ParamData> co
std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const & commandData, std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const & commandData,
size_t returnParamIndex, size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool isStructureChain ) const bool isStructureChain ) const
{ {
assert( ( returnParamIndex == INVALID_INDEX ) || ( returnParamIndex < commandData.params.size() ) ); assert( ( returnParamIndex == INVALID_INDEX ) || ( returnParamIndex < commandData.params.size() ) );
#if !defined( NDEBUG )
for ( auto vpi : vectorParamIndices )
{
assert( ( vpi.first != vpi.second ) && ( vpi.first < commandData.params.size() ) &&
( ( vpi.second == INVALID_INDEX ) || ( vpi.second < commandData.params.size() ) ) );
}
#endif
std::string enhancedReturnType; std::string enhancedReturnType;
if ( returnParamIndex != INVALID_INDEX ) if ( returnParamIndex != INVALID_INDEX )
{ {
@ -7146,24 +7228,13 @@ std::string VulkanHppGenerator::determineEnhancedReturnType( CommandData const &
// -> we can return that parameter // -> we can return that parameter
assert( ( commandData.returnType == "void" ) || ( commandData.returnType == "VkResult" ) ); assert( ( commandData.returnType == "void" ) || ( commandData.returnType == "VkResult" ) );
assert( commandData.successCodes.empty() || ( commandData.successCodes[0] == "VK_SUCCESS" ) ); assert( commandData.successCodes.empty() || ( commandData.successCodes[0] == "VK_SUCCESS" ) );
if ( vectorParamIndices.find( returnParamIndex ) != vectorParamIndices.end() ) enhancedReturnType = ( commandData.params[returnParamIndex].type.type == "void" )
{ ? "std::vector<uint8_t,Allocator>" // the return parameter is a vector-type parameter
enhancedReturnType = ( commandData.params[returnParamIndex].type.type == "void" ) : isStructureChain
? "std::vector<uint8_t,Allocator>" // the return parameter is a vector-type parameter ? "std::vector<StructureChain,Allocator>" // for structureChain returns, it's just
: isStructureChain // a vector of StrutureChains
? "std::vector<StructureChain,Allocator>" // for structureChain returns, it's just : "std::vector<" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ) +
// a vector of StrutureChains ",Allocator>"; // for the other parameters, we use a vector of the pure type
: "std::vector<" + stripPrefix( commandData.params[returnParamIndex].type.type, "Vk" ) +
",Allocator>"; // for the other parameters, we use a vector of the pure type
}
else
{
// it's a simple parameter -> get the type and just remove the trailing '*' (originally, it's a pointer)
assert( commandData.params[returnParamIndex].type.postfix.back() == '*' );
assert( ( commandData.params[returnParamIndex].type.prefix.find( "const" ) == std::string::npos ) &&
( commandData.params[returnParamIndex].type.postfix.find( "const" ) == std::string::npos ) );
enhancedReturnType = stripPostfix( commandData.params[returnParamIndex].type.compose(), "*" );
}
} }
else if ( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) ) else if ( ( commandData.returnType == "VkResult" ) && ( commandData.successCodes.size() == 1 ) )
{ {
@ -7225,9 +7296,9 @@ size_t VulkanHppGenerator::determineReturnParamIndex( CommandData const &
std::set<size_t> VulkanHppGenerator::determineSkippedParams( std::string const & handleType, std::set<size_t> VulkanHppGenerator::determineSkippedParams( std::string const & handleType,
std::vector<ParamData> const & params, std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex ) const std::vector<size_t> const & returnParamIndices ) const
{ {
std::set<size_t> skippedParams = { returnParamIndex }; std::set<size_t> skippedParams = { returnParamIndices.begin(), returnParamIndices.end() };
if ( !handleType.empty() ) if ( !handleType.empty() )
{ {
@ -7236,7 +7307,10 @@ std::set<size_t> VulkanHppGenerator::determineSkippedParams( std::string const &
for ( auto const & vpi : vectorParamIndices ) for ( auto const & vpi : vectorParamIndices )
{ {
if ( ( vpi.first != returnParamIndex ) || params[vpi.second].type.isValue() ) if ( ( std::find_if( returnParamIndices.begin(),
returnParamIndices.end(),
[&vpi]( size_t rpi ) { return vpi.first == rpi; } ) == returnParamIndices.end() ) ||
params[vpi.second].type.isValue() )
{ {
skippedParams.insert( vpi.second ); skippedParams.insert( vpi.second );
} }

23
VulkanHppGenerator.hpp
View File

@ -289,7 +289,6 @@ private:
size_t templateParamIndex, size_t templateParamIndex,
bool twoStep, bool twoStep,
bool firstCall ) const; bool firstCall ) const;
void appendArgumentVulkanType( std::string & str, ParamData const & paramData ) const;
void appendBitmask( std::string & os, void appendBitmask( std::string & os,
std::string const & bitmaskName, std::string const & bitmaskName,
std::string const & bitmaskType, std::string const & bitmaskType,
@ -442,9 +441,7 @@ private:
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool skip, bool skip,
bool argEncountered, bool argEncountered,
bool isTemplateParam, bool isTemplateParam ) const;
bool withDefaults,
bool withAllocator ) const;
void appendFunctionHeaderArgumentEnhancedPointer( std::string & str, void appendFunctionHeaderArgumentEnhancedPointer( std::string & str,
ParamData const & param, ParamData const & param,
std::string const & strippedParameterName ) const; std::string const & strippedParameterName ) const;
@ -452,9 +449,7 @@ private:
ParamData const & param, ParamData const & param,
std::string const & strippedParameterName, std::string const & strippedParameterName,
bool hasSizeParam, bool hasSizeParam,
bool isTemplateParam, bool isTemplateParam ) const;
bool withDefaults,
bool withAllocator ) const;
void appendFunctionHeaderArguments( std::string & str, void appendFunctionHeaderArguments( std::string & str,
CommandData const & commandData, CommandData const & commandData,
size_t returnParamIndex, size_t returnParamIndex,
@ -521,13 +516,15 @@ private:
std::set<size_t> const & skippedParams, std::set<size_t> const & skippedParams,
bool definition ) const; bool definition ) const;
std::string constructCallArgument( ParamData const & param, bool enhanced ) const; std::string constructCallArgument( ParamData const & param, bool enhanced ) const;
std::string constructCallArgumentsEnumerateVectors( std::vector<ParamData> const & params, std::string constructCallArgumentsEnumerateVectors( std::string const & handle,
std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool vectorAsNullptr ) const; bool vectorAsNullptr ) const;
std::string constructCallArgumentsGetValue( std::string const & handle, std::string constructCallArgumentsGetValue( std::string const & handle,
std::vector<ParamData> const & params, std::vector<ParamData> const & params,
size_t skippedParams ) const; size_t skippedParams ) const;
std::string constructCallArgumentsGetVector( std::vector<ParamData> const & params, std::string constructCallArgumentsGetVector( std::string const & handle,
std::vector<ParamData> const & params,
std::vector<size_t> const & returnParamIndex, std::vector<size_t> const & returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
bool singular ) const; bool singular ) const;
@ -538,6 +535,11 @@ private:
CommandData const & commandData, CommandData const & commandData,
bool definition, bool definition,
std::map<size_t, size_t> const & vectorParamIndices ) const; std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string constructCommandResultEnumerate( std::string const & name,
CommandData const & commandData,
bool definition,
std::pair<size_t, size_t> const & vectorParamIndices,
bool withAllocators ) const;
std::string constructCommandResultEnumerateTwoVectors( std::string const & name, std::string constructCommandResultEnumerateTwoVectors( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
bool definition, bool definition,
@ -679,7 +681,6 @@ private:
std::set<size_t> const & skippedParams ) const; std::set<size_t> const & skippedParams ) const;
std::string determineEnhancedReturnType( CommandData const & commandData, std::string determineEnhancedReturnType( CommandData const & commandData,
size_t returnParamIndex, size_t returnParamIndex,
std::map<size_t, size_t> const & vectorParamIndices,
bool isStructureChain ) const; bool isStructureChain ) const;
size_t determineReturnParamIndex( CommandData const & commandData, size_t determineReturnParamIndex( CommandData const & commandData,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
@ -687,7 +688,7 @@ private:
std::set<size_t> determineSkippedParams( std::string const & handleType, std::set<size_t> determineSkippedParams( std::string const & handleType,
std::vector<ParamData> const & params, std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices, std::map<size_t, size_t> const & vectorParamIndices,
size_t returnParamIndex ) const; std::vector<size_t> const & returnParamIndex ) const;
std::string determineSubStruct( std::pair<std::string, StructureData> const & structure ) const; std::string determineSubStruct( std::pair<std::string, StructureData> const & structure ) const;
size_t determineTemplateParamIndex( std::vector<ParamData> const & params, size_t determineTemplateParamIndex( std::vector<ParamData> const & params,
std::map<size_t, size_t> const & vectorParamIndices ) const; std::map<size_t, size_t> const & vectorParamIndices ) const;

1654
vulkan/vulkan.hpp
View File

File diff suppressed because it is too large Load Diff