mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1082 from asuessenbach/singular

Browse Source 
Add "singular" version of functions returning a vector of values and one value, now returning just a pair of values
This commit is contained in:
Andreas Süßenbach 2021-09-27 17:59:08 +02:00 committed by GitHub
commit 6307ce404e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 347 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

439
VulkanHppGenerator.cpp
View File

@ -2242,7 +2242,6 @@ std::string VulkanHppGenerator::generateCallArgumentsEnhanced( std::vector<Param
size_t initialSkipCount, size_t initialSkipCount,
bool nonConstPointerAsNullptr, bool nonConstPointerAsNullptr,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices,
bool raiiHandleMemberFunction ) const bool raiiHandleMemberFunction ) const
{ {
assert( initialSkipCount <= params.size() ); assert( initialSkipCount <= params.size() );
@ -2270,8 +2269,8 @@ std::string VulkanHppGenerator::generateCallArgumentsEnhanced( std::vector<Param
{ {
arguments += ", "; arguments += ", ";
} }
arguments += generateCallArgumentEnhanced( arguments +=
params, i, nonConstPointerAsNullptr, singularParams, returnParamIndices, raiiHandleMemberFunction ); generateCallArgumentEnhanced( params, i, nonConstPointerAsNullptr, singularParams, raiiHandleMemberFunction );
encounteredArgument = true; encounteredArgument = true;
} }
return arguments; return arguments;
@ -2327,7 +2326,6 @@ std::string VulkanHppGenerator::generateCallArgumentEnhanced( std::vector<ParamD
size_t paramIndex, size_t paramIndex,
bool nonConstPointerAsNullptr, bool nonConstPointerAsNullptr,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices,
bool raiiHandleMemberFunction ) const bool raiiHandleMemberFunction ) const
{ {
std::string argument; std::string argument;
@ -2346,7 +2344,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhanced( std::vector<ParamD
} }
else else
{ {
argument = generateCallArgumentEnhancedValue( params, paramIndex, singularParams, returnParamIndices ); argument = generateCallArgumentEnhancedValue( params, paramIndex, singularParams );
} }
assert( !argument.empty() ); assert( !argument.empty() );
return argument; return argument;
@ -2451,7 +2449,7 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedNonConstPointer( Par
{ {
argument = "nullptr"; argument = "nullptr";
} }
else if ( beginsWith( param.type.type, "Vk" ) || ( param.type.type == "void" ) ) else
{ {
if ( singularParams.find( paramIndex ) != singularParams.end() ) if ( singularParams.find( paramIndex ) != singularParams.end() )
{ {
@ -2462,25 +2460,19 @@ std::string VulkanHppGenerator::generateCallArgumentEnhancedNonConstPointer( Par
// get the data of the array, which also covers no data -> no need to look at param.optional // get the data of the array, which also covers no data -> no need to look at param.optional
argument = name + ".data()"; argument = name + ".data()";
} }
if ( !raiiHandleMemberFunction || !isHandleType( param.type.type ) ) if ( ( beginsWith( param.type.type, "Vk" ) || ( param.type.type == "void" ) ) &&
( !raiiHandleMemberFunction || !isHandleType( param.type.type ) ) )
{ {
argument = "reinterpret_cast<" + param.type.type + " *>( " + argument + " )"; argument = "reinterpret_cast<" + param.type.type + " *>( " + argument + " )";
} }
} }
else
{
assert( !param.optional );
argument = name + ".data()";
}
} }
return argument; return argument;
} }
std::string std::string VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector<ParamData> const & params,
VulkanHppGenerator::generateCallArgumentEnhancedValue( std::vector<ParamData> const & params, size_t paramIndex,
size_t paramIndex, std::set<size_t> const & singularParams ) const
std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices ) const
{ {
std::string argument; std::string argument;
ParamData const & param = params[paramIndex]; ParamData const & param = params[paramIndex];
@ -2515,30 +2507,15 @@ std::string
} }
else else
{ {
if ( singularParams.find( paramIndex ) != singularParams.end() ) auto pointerIt =
std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { return pd.len == param.name; } );
if ( pointerIt != params.end() )
{ {
assert( !param.optional ); // this parameter is the len of some other -> replace it with that parameter's size
assert( param.arraySizes.empty() ); assert( param.arraySizes.empty() );
assert( ( param.type.type == "size_t" ) || ( param.type.type == "uint32_t" ) ); assert( ( param.type.type == "size_t" ) || ( param.type.type == "uint32_t" ) );
assert( returnParamIndices.size() == 1 ); if ( singularParams.find( paramIndex ) == singularParams.end() )
if ( params[returnParamIndices[0]].type.type == "void" )
{ {
argument = "sizeof( T )";
}
else
{
argument = "1";
}
}
else
{
auto pointerIt =
std::find_if( params.begin(), params.end(), [&param]( ParamData const & pd ) { return pd.len == param.name; } );
if ( pointerIt != params.end() )
{
// this parameter is the len of some other -> replace it with that parameter's size
assert( param.arraySizes.empty() );
assert( ( param.type.type == "size_t" ) || ( param.type.type == "uint32_t" ) );
argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()"; argument = startLowerCase( stripPrefix( pointerIt->name, "p" ) ) + ".size()";
if ( pointerIt->type.type == "void" ) if ( pointerIt->type.type == "void" )
{ {
@ -2547,11 +2524,22 @@ std::string
} }
else else
{ {
assert( !param.optional ); if ( pointerIt->type.type == "void" )
assert( param.arraySizes.size() <= 1 ); {
argument = param.name; argument = "sizeof( T )";
}
else
{
argument = "1";
}
} }
} }
else
{
assert( !param.optional );
assert( param.arraySizes.size() <= 1 );
argument = param.name;
}
} }
return argument; return argument;
} }
@ -2775,8 +2763,7 @@ std::string VulkanHppGenerator::generateCommandResult( std::string const &
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, {}, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -2870,10 +2857,10 @@ std::string VulkanHppGenerator::generateCommandResultEnumerate( std::string cons
{ "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.second].name, "p" ) ) }, { "counterName", startLowerCase( stripPrefix( commandData.params[vectorParamIndices.second].name, "p" ) ) },
{ "counterType", commandData.params[vectorParamIndices.second].type.type }, { "counterType", commandData.params[vectorParamIndices.second].type.type },
{ "firstCallArguments", { "firstCallArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, {}, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, false ) },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "secondCallArguments", { "secondCallArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, {}, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
{ "typenameCheck", typenameCheck }, { "typenameCheck", typenameCheck },
{ "vectorAllocator", withAllocator ? ( "( " + startLowerCase( allocatorType ) + " )" ) : "" }, { "vectorAllocator", withAllocator ? ( "( " + startLowerCase( allocatorType ) + " )" ) : "" },
{ "vectorElementType", vectorElementType }, { "vectorElementType", vectorElementType },
@ -2987,12 +2974,12 @@ 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",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, false ) },
{ "firstVectorName", startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ) }, { "firstVectorName", startLowerCase( stripPrefix( commandData.params[firstVectorParamIt->first].name, "p" ) ) },
{ "nodiscard", nodiscard }, { "nodiscard", nodiscard },
{ "pairConstructor", pairConstructor }, { "pairConstructor", pairConstructor },
{ "secondCallArguments", { "secondCallArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
{ "secondVectorName", { "secondVectorName",
startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ) }, startLowerCase( stripPrefix( commandData.params[secondVectorParamIt->first].name, "p" ) ) },
{ "templateTypeFirst", templateTypeFirst }, { "templateTypeFirst", templateTypeFirst },
@ -3140,9 +3127,7 @@ std::string VulkanHppGenerator::generateCommandResultGetChain( std::string const
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { nonConstPointerIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3230,9 +3215,7 @@ std::string VulkanHppGenerator::generateCommandResultGetHandleUnique( std::strin
functionTemplate, functionTemplate,
{ { "allocator", allocator }, { { "allocator", allocator },
{ "argumentList", argumentList }, { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { nonConstPointerIndex }, false ) },
{ "className", className }, { "className", className },
{ "classSeparator", className.empty() ? "" : "::" }, { "classSeparator", className.empty() ? "" : "::" },
{ "commandName", commandName }, { "commandName", commandName },
@ -3260,6 +3243,82 @@ std::string VulkanHppGenerator::generateCommandResultGetHandleUnique( std::strin
} }
} }
std::string VulkanHppGenerator::generateCommandResultGetSingularAndValue(
std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices ) const
{
assert( !commandData.handle.empty() && ( commandData.returnType == "VkResult" ) );
assert( ( vectorParamIndices.size() == 2 ) && ( returnParamIndices.size() == 2 ) );
assert( vectorParamIndices.find( returnParamIndices[0] ) != vectorParamIndices.end() );
assert( vectorParamIndices.find( returnParamIndices[1] ) == vectorParamIndices.end() );
assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
assert( commandData.returnType == "VkResult" );
std::set<size_t> skippedParameters =
determineSkippedParams( commandData.params, initialSkipCount, vectorParamIndices, returnParamIndices, false );
std::set<size_t> singularParameters = determineSingularParams( returnParamIndices[0], vectorParamIndices );
std::string argumentList = generateArgumentListEnhanced(
commandData.params, skippedParameters, singularParameters, definition, false, false, true );
std::string commandName = stripPluralS( generateCommandName( name, commandData.params, initialSkipCount, m_tags ) );
std::string nodiscard = generateNoDiscard( 1 < commandData.successCodes.size(), 1 < commandData.errorCodes.size() );
assert( !beginsWith( commandData.params[returnParamIndices[0]].type.type, "Vk" ) );
std::string singularElementType = commandData.params[returnParamIndices[0]].type.type;
assert( !beginsWith( commandData.params[returnParamIndices[1]].type.type, "Vk" ) );
std::string valueType = commandData.params[returnParamIndices[1]].type.type;
if ( definition )
{
std::string const functionTemplate =
R"( template <typename Dispatch>
${nodiscard}VULKAN_HPP_INLINE typename ResultValueType<std::pair<${singularElementType}, ${valueType}>>::type ${className}${classSeparator}${commandName}( ${argumentList} ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<${singularElementType},${valueType}> data;
${singularElementType} & ${singularName} = data.first;
${valueType} & ${valueName} = data.second;
Result result = static_cast<Result>( d.${vkCommand}( ${callArguments} ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::${className}${classSeparator}${commandName}"${successCodeList} );
})";
return replaceWithMap(
functionTemplate,
{ { "argumentList", argumentList },
{ "callArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, singularParameters, false ) },
{ "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName },
{ "nodiscard", nodiscard },
{ "singularElementType", singularElementType },
{ "singularName",
startLowerCase( stripPluralS( stripPrefix( commandData.params[returnParamIndices[0]].name, "p" ) ) ) },
{ "successCodeList", generateSuccessCodeList( commandData.successCodes ) },
{ "valueName", startLowerCase( stripPrefix( commandData.params[returnParamIndices[1]].name, "p" ) ) },
{ "valueType", valueType },
{ "vkCommand", name } } );
}
else
{
std::string const functionTemplate =
R"( template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
${nodiscard}typename ResultValueType<std::pair<${singularElementType}, ${valueType}>>::type ${commandName}( ${argumentList} ) const;)";
return replaceWithMap( functionTemplate,
{ { "argumentList", argumentList },
{ "commandName", commandName },
{ "nodiscard", nodiscard },
{ "singularElementType", singularElementType },
{ "valueType", valueType } } );
}
}
std::string VulkanHppGenerator::generateCommandResultGetTwoValues( std::string const & name, std::string VulkanHppGenerator::generateCommandResultGetTwoValues( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -3302,8 +3361,7 @@ std::string VulkanHppGenerator::generateCommandResultGetTwoValues( std::string c
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, returnParamIndices, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3373,8 +3431,7 @@ std::string
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, {}, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3443,9 +3500,7 @@ std::string VulkanHppGenerator::generateCommandResultGetValue( std::string const
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3573,9 +3628,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVector( std::string cons
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3656,8 +3709,7 @@ std::string
{ { "allocateInitializer", withAllocator ? ( ", " + startLowerCase( allocatorType ) ) : "" }, { { "allocateInitializer", withAllocator ? ( ", " + startLowerCase( allocatorType ) ) : "" },
{ "allocatorType", allocatorType }, { "allocatorType", allocatorType },
{ "argumentList", argumentList }, { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, returnParamIndices, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3802,9 +3854,7 @@ std::string
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3882,8 +3932,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesSingular(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
generateCallArgumentsEnhanced( generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, singularParams, false ) },
commandData.params, initialSkipCount, false, singularParams, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -3990,9 +4039,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUnique(
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { returnParamIndex }, false ) },
{ "className", className }, { "className", className },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
{ "commandName", commandName }, { "commandName", commandName },
@ -4073,8 +4120,7 @@ std::string VulkanHppGenerator::generateCommandResultGetVectorOfHandlesUniqueSin
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
generateCallArgumentsEnhanced( generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, singularParams, false ) },
commandData.params, initialSkipCount, false, singularParams, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -4140,8 +4186,7 @@ std::string
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
generateCallArgumentsEnhanced( generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, singularParams, false ) },
commandData.params, initialSkipCount, false, singularParams, { returnParamIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -4819,7 +4864,7 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors2Ret
!isHandleType( commandData.params[vectorParamIndices.begin()->first].type.type ) && !isHandleType( commandData.params[vectorParamIndices.begin()->first].type.type ) &&
!isStructureChainAnchor( commandData.params[vectorParamIndices.begin()->first].type.type ) ) !isStructureChainAnchor( commandData.params[vectorParamIndices.begin()->first].type.type ) )
{ {
return generateCommandSetStandardEnhancedWithAllocatorDeprecated( return generateCommandSetStandardEnhancedWithAllocatorSingularDeprecated(
definition, definition,
generateCommandStandard( name, commandData, initialSkipCount, definition ), generateCommandStandard( name, commandData, initialSkipCount, definition ),
generateCommandResultGetValueDeprecated( generateCommandResultGetValueDeprecated(
@ -4827,7 +4872,9 @@ std::string VulkanHppGenerator::generateCommandResultSingleSuccessWithErrors2Ret
generateCommandResultGetVectorAndValue( generateCommandResultGetVectorAndValue(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndices, false ), name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndices, false ),
generateCommandResultGetVectorAndValue( generateCommandResultGetVectorAndValue(
name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndices, true ) ); name, commandData, initialSkipCount, definition, vectorParamIndices, returnParamIndices, true ),
generateCommandResultGetSingularAndValue(
name, commandData, initialSkipCount, definition, returnParamIndices, vectorParamIndices ) );
} }
} }
} }
@ -4981,12 +5028,13 @@ ${commandEnhancedChainedWithAllocator}
{ "newlineOnDefinition", definition ? "\n" : "" } } ) ); { "newlineOnDefinition", definition ? "\n" : "" } } ) );
} }
std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorDeprecated( std::string VulkanHppGenerator::generateCommandSetStandardEnhancedWithAllocatorSingularDeprecated(
bool definition, bool definition,
std::string const & standard, std::string const & standard,
std::string const & enhancedDeprecated, std::string const & enhancedDeprecated,
std::string const & enhanced, std::string const & enhanced,
std::string const & enhancedWithAllocator ) const std::string const & enhancedWithAllocator,
std::string const & enhancedSingular ) const
{ {
const std::string commandTemplate = R"( const std::string commandTemplate = R"(
${commandStandard}${newlineOnDefinition} ${commandStandard}${newlineOnDefinition}
@ -4994,6 +5042,7 @@ ${commandStandard}${newlineOnDefinition}
${commandEnhancedDeprecated}${newlineOnDefinition} ${commandEnhancedDeprecated}${newlineOnDefinition}
${commandEnhanced}${newlineOnDefinition} ${commandEnhanced}${newlineOnDefinition}
${commandEnhancedWithAllocator} ${commandEnhancedWithAllocator}
${commandEnhancedSingular}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
)"; )";
@ -5001,6 +5050,7 @@ ${commandEnhancedWithAllocator}
commandTemplate, commandTemplate,
std::map<std::string, std::string>( { { "commandEnhanced", enhanced }, std::map<std::string, std::string>( { { "commandEnhanced", enhanced },
{ "commandEnhancedDeprecated", enhancedDeprecated }, { "commandEnhancedDeprecated", enhancedDeprecated },
{ "commandEnhancedSingular", enhancedSingular },
{ "commandEnhancedWithAllocator", enhancedWithAllocator }, { "commandEnhancedWithAllocator", enhancedWithAllocator },
{ "commandStandard", standard }, { "commandStandard", standard },
{ "newlineOnDefinition", definition ? "\n" : "" } } ) ); { "newlineOnDefinition", definition ? "\n" : "" } } ) );
@ -5206,8 +5256,7 @@ std::string VulkanHppGenerator::generateCommandType( std::string const & name,
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, {}, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -5297,8 +5346,7 @@ std::string VulkanHppGenerator::generateCommandVoid( std::string const &
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, {}, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -5591,9 +5639,9 @@ std::string VulkanHppGenerator::generateCommandVoidEnumerate( 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",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, false ) },
{ "secondCallArguments", { "secondCallArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
{ "typenameCheck", typenameCheck }, { "typenameCheck", typenameCheck },
{ "vectorAllocator", { "vectorAllocator",
withAllocators withAllocators
@ -5686,9 +5734,9 @@ std::string VulkanHppGenerator::generateCommandVoidEnumerateChained( std::string
{ "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",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, true, {}, false ) },
{ "secondCallArguments", { "secondCallArguments",
generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, returnParamIndices, false ) }, generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
{ "structureChainAllocator", withAllocators ? ( ", structureChainAllocator" ) : "" }, { "structureChainAllocator", withAllocators ? ( ", structureChainAllocator" ) : "" },
{ "typenameCheck", typenameCheck }, { "typenameCheck", typenameCheck },
{ "vectorElementType", vectorElementType }, { "vectorElementType", vectorElementType },
@ -5747,9 +5795,7 @@ std::string VulkanHppGenerator::generateCommandVoidGetChain( std::string const &
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { nonConstPointerIndex }, false ) },
{ "className", { "className",
initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" }, initialSkipCount ? stripPrefix( commandData.params[initialSkipCount - 1].type.type, "Vk" ) : "" },
{ "classSeparator", commandData.handle.empty() ? "" : "::" }, { "classSeparator", commandData.handle.empty() ? "" : "::" },
@ -5839,9 +5885,7 @@ std::string VulkanHppGenerator::generateCommandVoidGetValue( std::string const &
return replaceWithMap( return replaceWithMap(
functionTemplate, functionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments", generateCallArgumentsEnhanced( commandData.params, initialSkipCount, false, {}, false ) },
generateCallArgumentsEnhanced(
commandData.params, initialSkipCount, false, {}, { returnParamIndex }, false ) },
{ "className", className }, { "className", className },
{ "classSeparator", classSeparator }, { "classSeparator", classSeparator },
{ "commandName", commandName }, { "commandName", commandName },
@ -7384,7 +7428,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -7485,8 +7529,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string valueName = std::string valueName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -7551,8 +7595,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true );
std::string dataName = std::string dataName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -7613,8 +7657,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string dataName = std::string dataName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -7734,10 +7778,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
std::string counterName = std::string counterName =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
std::string firstCallArguments = generateCallArgumentsEnhanced( std::string firstCallArguments =
commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, true, {}, true );
std::string secondCallArguments = generateCallArgumentsEnhanced( std::string secondCallArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string vectorName = std::string vectorName =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
@ -7872,12 +7916,12 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessWithE
} }
)"; )";
std::string firstCallArguments = generateCallArgumentsEnhanced( std::string firstCallArguments =
commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, true, {}, true );
std::string firstVectorName = std::string firstVectorName =
startLowerCase( stripPrefix( commandIt->second.params[firstVectorParamIt->first].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[firstVectorParamIt->first].name, "p" ) );
std::string secondCallArguments = generateCallArgumentsEnhanced( std::string secondCallArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string secondVectorName = std::string secondVectorName =
startLowerCase( stripPrefix( commandIt->second.params[secondVectorParamIt->first].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[secondVectorParamIt->first].name, "p" ) );
@ -7947,7 +7991,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessNoEr
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -8029,7 +8073,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -8094,8 +8138,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string returnType = std::string returnType =
stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
std::string returnVariable = std::string returnVariable =
@ -8238,8 +8282,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string valueName = std::string valueName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -8307,8 +8351,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, singularParams, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true );
std::string dataName = std::string dataName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -8370,8 +8414,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string dataName = std::string dataName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
@ -8409,6 +8453,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
bool definition, bool definition,
std::vector<size_t> const & returnParamIndices ) const std::vector<size_t> const & returnParamIndices ) const
{ {
std::string str;
if ( commandIt->second.params[returnParamIndices[0]].type.type == "uint64_t" ) if ( commandIt->second.params[returnParamIndices[0]].type.type == "uint64_t" )
{ {
if ( commandIt->second.params[returnParamIndices[1]].type.type == "uint64_t" ) if ( commandIt->second.params[returnParamIndices[1]].type.type == "uint64_t" )
@ -8432,8 +8477,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
{ {
// two returns and two vectors! But one input vector, one output vector of the same size, // two returns and two vectors! But one input vector, one output vector of the same size,
// and one output value // and one output value
return generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue( str = generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue(
commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition ); commandIt, initialSkipCount, vectorParamIndices, returnParamIndices, definition );
str += generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueSingularValue(
commandIt, initialSkipCount, definition, returnParamIndices, vectorParamIndices );
} }
} }
} }
@ -8442,7 +8489,82 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
} }
} }
return ""; return str;
}
std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueSingularValue(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
bool definition,
std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices ) const
{
std::set<size_t> skippedParameters =
determineSkippedParams( commandIt->second.params, initialSkipCount, vectorParamIndices, returnParamIndices, false );
assert( std::next( vectorParamIndices.begin() )->first == returnParamIndices[0] );
assert( vectorParamIndices.begin()->second == std::next( vectorParamIndices.begin() )->second );
std::set<size_t> singularParams = determineSingularParams( returnParamIndices[0], vectorParamIndices );
std::string argumentList = generateArgumentListEnhanced(
commandIt->second.params, skippedParameters, singularParams, definition, false, false, false );
std::string commandName =
stripPluralS( generateCommandName( commandIt->first, commandIt->second.params, initialSkipCount, m_tags ) );
std::string singularElementType = commandIt->second.params[returnParamIndices[0]].type.type;
std::string valueType = commandIt->second.params[returnParamIndices[1]].type.type;
if ( definition )
{
std::string const definitionTemplate =
R"(
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<${singularElementType}, ${valueType}> ${className}::${commandName}( ${argumentList} ) const
{${functionPointerCheck}
std::pair<${singularElementType}, ${valueType}> data;
${singularElementType} & ${singularName} = data.first;
${valueType} & ${valueName} = data.second;
VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->${vkCommand}( ${callArguments} ) );
if ( ${failureCheck} )
{
throwResultException( result, VULKAN_HPP_NAMESPACE_STRING"::${className}::${commandName}" );
}
return data;
}
)";
std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true );
std::string valueName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndices[1]].name, "p" ) );
std::string singularName =
startLowerCase( stripPluralS( stripPrefix( commandIt->second.params[returnParamIndices[0]].name, "p" ) ) );
std::string vectorSize =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
".size()";
return replaceWithMap(
definitionTemplate,
{ { "argumentList", argumentList },
{ "callArguments", callArguments },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName },
{ "failureCheck", generateFailureCheck( commandIt->second.successCodes ) },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
{ "singularElementType", singularElementType },
{ "valueName", valueName },
{ "singularName", singularName },
{ "valueType", valueType },
{ "vkCommand", commandIt->first } } );
}
else
{
std::string const declarationTemplate =
R"(
VULKAN_HPP_NODISCARD std::pair<${singularElementType}, ${valueType}> ${commandName}( ${argumentList} ) const;
)";
return replaceWithMap( declarationTemplate,
{ { "argumentList", argumentList },
{ "commandName", commandName },
{ "singularElementType", singularElementType },
{ "valueType", valueType } } );
}
} }
std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue( std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue(
@ -8478,8 +8600,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultSingleSuccessWith
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string valueName = std::string valueName =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[1]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[1]].name, "p" ) );
std::string vectorName = std::string vectorName =
@ -8568,7 +8690,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandValue0Return0VectorType
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -8627,7 +8749,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandValue0Return0VectorVkTy
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -8745,7 +8867,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid0Return(
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
? generateVectorSizeCheck( ? generateVectorSizeCheck(
@ -8806,8 +8928,8 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnChain(
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string returnType = std::string returnType =
stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" ); stripPostfix( commandIt->second.params[nonConstPointerParamIndices[0]].type.compose(), "*" );
std::string returnVariable = std::string returnVariable =
@ -8874,8 +8996,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid1ReturnValue(
definitionTemplate, definitionTemplate,
{ { "argumentList", argumentList }, { { "argumentList", argumentList },
{ "callArguments", { "callArguments",
generateCallArgumentsEnhanced( generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true ) },
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ) },
{ "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) }, { "className", stripPrefix( commandIt->second.params[initialSkipCount - 1].type.type, "Vk" ) },
{ "commandName", commandName }, { "commandName", commandName },
{ "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) }, { "functionPointerCheck", generateFunctionPointerCheck( commandIt->first, commandIt->second.referencedIn ) },
@ -8947,10 +9068,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateCha
} }
)"; )";
std::string firstCallArguments = generateCallArgumentsEnhanced( std::string firstCallArguments =
commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, true, {}, true );
std::string secondCallArguments = generateCallArgumentsEnhanced( std::string secondCallArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string vectorElementType = std::string vectorElementType =
stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" ); stripPostfix( commandIt->second.params[vectorParamIndices.begin()->first].type.compose(), "*" );
std::string vectorName = std::string vectorName =
@ -9021,10 +9142,10 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandVoid2ReturnEnumerateVal
std::string counterName = std::string counterName =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->second].name, "p" ) );
std::string firstCallArguments = generateCallArgumentsEnhanced( std::string firstCallArguments =
commandIt->second.params, initialSkipCount, true, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, true, {}, true );
std::string secondCallArguments = generateCallArgumentsEnhanced( std::string secondCallArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string vectorName = std::string vectorName =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) );
@ -9341,13 +9462,11 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorArguments( std::str
return arguments; return arguments;
} }
std::string std::string VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( std::string const & handleType,
VulkanHppGenerator::generateRAIIHandleConstructorCallArguments( std::string const & handleType, std::vector<ParamData> const & params,
std::vector<ParamData> const & params, bool nonConstPointerAsNullptr,
bool nonConstPointerAsNullptr, std::set<size_t> const & singularParams,
std::set<size_t> const & singularParams, bool allocatorIsMemberVariable ) const
std::vector<size_t> const & returnParamIndices,
bool allocatorIsMemberVariable ) const
{ {
std::string arguments; std::string arguments;
bool encounteredArgument = false; bool encounteredArgument = false;
@ -9406,8 +9525,7 @@ std::string
else else
{ {
assert( !param.optional ); assert( !param.optional );
arguments += arguments += generateCallArgumentEnhanced( params, i, nonConstPointerAsNullptr, singularParams, true );
generateCallArgumentEnhanced( params, i, nonConstPointerAsNullptr, singularParams, returnParamIndices, true );
} }
encounteredArgument = true; encounteredArgument = true;
} }
@ -9471,14 +9589,14 @@ ${leave})";
{ "dispatcherType", dispatcherType }, { "dispatcherType", dispatcherType },
{ "enter", enter }, { "enter", enter },
{ "firstCallArguments", { "firstCallArguments",
generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, true, {}, {}, true ) }, generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, true, {}, true ) },
{ "handleConstructorArguments", handleConstructorArguments }, { "handleConstructorArguments", handleConstructorArguments },
{ "handleName", startLowerCase( handleType ) }, { "handleName", startLowerCase( handleType ) },
{ "handleType", handleType }, { "handleType", handleType },
{ "leave", leave }, { "leave", leave },
{ "parentName", constructorIt->second.params.front().name }, { "parentName", constructorIt->second.params.front().name },
{ "secondCallArguments", { "secondCallArguments",
generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, {}, true ) }, generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, true ) },
{ "vectorElementType", handleParamIt->type.type }, { "vectorElementType", handleParamIt->type.type },
{ "vectorName", startLowerCase( stripPrefix( handleParamIt->name, "p" ) ) } } ); { "vectorName", startLowerCase( stripPrefix( handleParamIt->name, "p" ) ) } } );
} }
@ -9571,7 +9689,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorResult(
std::string const & leave ) const std::string const & leave ) const
{ {
std::string callArguments = generateRAIIHandleConstructorCallArguments( std::string callArguments = generateRAIIHandleConstructorCallArguments(
handle.first, constructorIt->second.params, false, {}, {}, handle.second.destructorIt != m_commands.end() ); handle.first, constructorIt->second.params, false, {}, handle.second.destructorIt != m_commands.end() );
std::string constructorArguments, dispatcherArgument, dispatcherInit, getDispatcher; std::string constructorArguments, dispatcherArgument, dispatcherInit, getDispatcher;
if ( handle.first == "VkInstance" ) if ( handle.first == "VkInstance" )
{ {
@ -9768,8 +9886,7 @@ ${leave})";
return replaceWithMap( return replaceWithMap(
constructorTemplate, constructorTemplate,
{ { "callArguments", { { "callArguments",
generateRAIIHandleConstructorCallArguments( generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, false ) },
handle.first, constructorIt->second.params, false, {}, {}, false ) },
{ "constructorArguments", { "constructorArguments",
generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ) }, generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ) },
{ "constructorCall", constructorIt->first }, { "constructorCall", constructorIt->first },
@ -9798,7 +9915,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVectorSingular(
std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices ); std::set<size_t> singularParams = determineSingularParams( returnParamIndex, vectorParamIndices );
std::string callArguments = generateRAIIHandleConstructorCallArguments( std::string callArguments = generateRAIIHandleConstructorCallArguments(
handle.first, constructorIt->second.params, false, singularParams, { returnParamIndex }, true ); handle.first, constructorIt->second.params, false, singularParams, true );
std::string initializationList = generateRAIIHandleConstructorInitializationList( std::string initializationList = generateRAIIHandleConstructorInitializationList(
handle.first, constructorIt, handle.second.destructorIt, !handle.second.secondLevelCommands.empty() ); handle.first, constructorIt, handle.second.destructorIt, !handle.second.secondLevelCommands.empty() );
std::string failureCheck = generateFailureCheck( constructorIt->second.successCodes ); std::string failureCheck = generateFailureCheck( constructorIt->second.successCodes );
@ -9838,7 +9955,7 @@ std::string VulkanHppGenerator::generateRAIIHandleConstructorVoid(
std::string const & leave ) const std::string const & leave ) const
{ {
std::string callArguments = std::string callArguments =
generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, {}, true ); generateRAIIHandleConstructorCallArguments( handle.first, constructorIt->second.params, false, {}, true );
std::string constructorArguments = std::string constructorArguments =
generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false ); generateRAIIHandleConstructorArguments( handle.first, constructorIt->second.params, false, false );
std::string initializationList = generateRAIIHandleConstructorInitializationList( std::string initializationList = generateRAIIHandleConstructorInitializationList(
@ -10876,8 +10993,8 @@ std::string VulkanHppGenerator::generateRAIIHandleMemberFunctionResultMultiGetTw
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, nonConstPointerParamIndices, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string valueName0 = std::string valueName0 =
startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) ); startLowerCase( stripPrefix( commandIt->second.params[nonConstPointerParamIndices[0]].name, "p" ) );
std::string valueName1 = std::string valueName1 =
@ -10975,7 +11092,7 @@ std::string VulkanHppGenerator::generateRAIIHandleCommandResultMultiSuccessNoErr
)"; )";
std::string callArguments = std::string callArguments =
generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, {}, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices ); std::pair<bool, std::map<size_t, std::vector<size_t>>> vectorSizeCheck = needsVectorSizeCheck( vectorParamIndices );
std::string vectorSizeCheckString = std::string vectorSizeCheckString =
vectorSizeCheck.first vectorSizeCheck.first
@ -11038,8 +11155,8 @@ std::string VulkanHppGenerator::generateRAIIHandleMemberFunctionResultSingleGetV
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, {}, { returnParamIndex }, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, {}, true );
std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ); std::string vectorName = startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) );
std::string vectorSize = std::string vectorSize =
startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) + startLowerCase( stripPrefix( commandIt->second.params[vectorParamIndices.begin()->first].name, "p" ) ) +
@ -11106,8 +11223,8 @@ std::string VulkanHppGenerator::generateRAIIHandleMemberFunctionResultSingleGetV
} }
)"; )";
std::string callArguments = generateCallArgumentsEnhanced( std::string callArguments =
commandIt->second.params, initialSkipCount, false, singularParams, { returnParamIndex }, true ); generateCallArgumentsEnhanced( commandIt->second.params, initialSkipCount, false, singularParams, true );
std::string vectorElementName = std::string vectorElementName =
stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) ); stripPluralS( startLowerCase( stripPrefix( commandIt->second.params[returnParamIndex].name, "p" ) ) );

31
VulkanHppGenerator.hpp
View File

@ -422,14 +422,12 @@ private:
size_t initialSkipCount, size_t initialSkipCount,
bool nonConstPointerAsNullptr, bool nonConstPointerAsNullptr,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices,
bool raiiHandleMemberFunction ) const; bool raiiHandleMemberFunction ) const;
std::string generateCallArgumentsStandard( std::string const & handle, std::vector<ParamData> const & params ) const; std::string generateCallArgumentsStandard( std::string const & handle, std::vector<ParamData> const & params ) const;
std::string generateCallArgumentEnhanced( std::vector<ParamData> const & params, std::string generateCallArgumentEnhanced( std::vector<ParamData> const & params,
size_t paramIndex, size_t paramIndex,
bool nonConstPointerAsNullptr, bool nonConstPointerAsNullptr,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices,
bool raiiHandleMemberFunction ) const; bool raiiHandleMemberFunction ) const;
std::string generateCallArgumentEnhancedConstPointer( ParamData const & param, std::string generateCallArgumentEnhancedConstPointer( ParamData const & param,
size_t paramIndex, size_t paramIndex,
@ -441,8 +439,7 @@ private:
bool raiiHandleMemberFunction ) const; bool raiiHandleMemberFunction ) const;
std::string generateCallArgumentEnhancedValue( std::vector<ParamData> const & params, std::string generateCallArgumentEnhancedValue( std::vector<ParamData> const & params,
size_t paramIndex, size_t paramIndex,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams ) const;
std::vector<size_t> const & returnParamIndices ) const;
std::string generateCommand( std::string const & name, std::string generateCommand( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -489,6 +486,12 @@ private:
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition,
size_t nonConstPointerIndex ) const; size_t nonConstPointerIndex ) const;
std::string generateCommandResultGetSingularAndValue( std::string const & name,
CommandData const & commandData,
size_t initialSkipCount,
bool definition,
std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateCommandResultGetTwoValues( std::string const & name, std::string generateCommandResultGetTwoValues( std::string const & name,
CommandData const & commandData, CommandData const & commandData,
size_t initialSkipCount, size_t initialSkipCount,
@ -682,11 +685,12 @@ private:
std::string const & enhancedChained, std::string const & enhancedChained,
std::string const & enhancedChainedWithAllocator ) const; std::string const & enhancedChainedWithAllocator ) const;
std::string std::string
generateCommandSetStandardEnhancedWithAllocatorDeprecated( bool definition, generateCommandSetStandardEnhancedWithAllocatorSingularDeprecated( bool definition,
std::string const & standard, std::string const & standard,
std::string const & enhancedDeprecated, std::string const & enhancedDeprecated,
std::string const & enhanced, std::string const & enhanced,
std::string const & enhancedWithAllocator ) const; std::string const & enhancedWithAllocator,
std::string const & enhancedSingular ) const;
std::string std::string
generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool definition, generateCommandSetStandardEnhancedWithAllocatorDeprecated2( bool definition,
std::string const & standard, std::string const & standard,
@ -878,7 +882,7 @@ private:
size_t initialSkipCount, size_t initialSkipCount,
bool definition ) const; bool definition ) const;
std::string generateRAIIHandleCommandResultMultiSuccessNoErrors( std::string generateRAIIHandleCommandResultMultiSuccessNoErrors(
std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const; std::map<std::string, CommandData>::const_iterator commandIt, size_t initialSkipCount, bool definition ) const;
std::string generateRAIIHandleCommandResultMultiSuccessNoErrors0Return( std::string generateRAIIHandleCommandResultMultiSuccessNoErrors0Return(
std::map<std::string, CommandData>::const_iterator commandIt, std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount, size_t initialSkipCount,
@ -984,6 +988,12 @@ private:
size_t initialSkipCount, size_t initialSkipCount,
bool definition, bool definition,
std::vector<size_t> const & returnParamIndices ) const; std::vector<size_t> const & returnParamIndices ) const;
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueSingularValue(
std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount,
bool definition,
std::vector<size_t> const & returnParamIndices,
std::map<size_t, size_t> const & vectorParamIndices ) const;
std::string generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue( std::string generateRAIIHandleCommandResultSingleSuccessWithErrors2ReturnValueVectorValue(
std::map<std::string, CommandData>::const_iterator commandIt, std::map<std::string, CommandData>::const_iterator commandIt,
size_t initialSkipCount, size_t initialSkipCount,
@ -1053,7 +1063,6 @@ private:
std::vector<ParamData> const & params, std::vector<ParamData> const & params,
bool nonConstPointerAsNullptr, bool nonConstPointerAsNullptr,
std::set<size_t> const & singularParams, std::set<size_t> const & singularParams,
std::vector<size_t> const & returnParamIndices,
bool allocatorIsMemberVariable ) const; bool allocatorIsMemberVariable ) const;
std::string generateRAIIHandleConstructorEnumerate( std::pair<std::string, HandleData> const & handle, std::string generateRAIIHandleConstructorEnumerate( std::pair<std::string, HandleData> const & handle,
std::map<std::string, CommandData>::const_iterator constructorIt, std::map<std::string, CommandData>::const_iterator constructorIt,

18
vulkan/vulkan_funcs.hpp
View File

@ -15558,6 +15558,24 @@ namespace VULKAN_HPP_NAMESPACE
&maxDeviation ) ); &maxDeviation ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
} }
template <typename Dispatch>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo,
Dispatch const & d ) const
{
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
std::pair<uint64_t, uint64_t> data;
uint64_t & timestamp = data.first;
uint64_t & maxDeviation = data.second;
Result result = static_cast<Result>(
d.vkGetCalibratedTimestampsEXT( m_device,
1,
reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ),
&timestamp,
&maxDeviation ) );
return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
}
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_NV_mesh_shader === //=== VK_NV_mesh_shader ===

4
vulkan/vulkan_handles.hpp
View File

@ -10748,6 +10748,10 @@ namespace VULKAN_HPP_NAMESPACE
ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos, ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
Uint64_tAllocator & uint64_tAllocator, Uint64_tAllocator & uint64_tAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
//=== VK_KHR_timeline_semaphore === //=== VK_KHR_timeline_semaphore ===

27
vulkan/vulkan_raii.hpp
View File

@ -3199,6 +3199,9 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT( VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t> getCalibratedTimestampsEXT(
ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const; ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos ) const;
VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const;
//=== VK_KHR_timeline_semaphore === //=== VK_KHR_timeline_semaphore ===
VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo,
@ -14944,6 +14947,30 @@ namespace VULKAN_HPP_NAMESPACE
return data; return data;
} }
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT & timestampInfo ) const
{
VULKAN_HPP_ASSERT(
getDispatcher()->vkGetCalibratedTimestampsEXT &&
"Function <vkGetCalibratedTimestampsEXT> needs extension <VK_EXT_calibrated_timestamps> enabled!" );
std::pair<uint64_t, uint64_t> data;
uint64_t & timestamp = data.first;
uint64_t & maxDeviation = data.second;
VULKAN_HPP_NAMESPACE::Result result =
static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT(
static_cast<VkDevice>( m_device ),
1,
reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( &timestampInfo ),
&timestamp,
&maxDeviation ) );
if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
{
throwResultException( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
}
return data;
}
//=== VK_NV_mesh_shader === //=== VK_NV_mesh_shader ===
VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount,